Changeset d67cdb7

doc/proposals/concurrency/Makefile

r201aeb9	rd67cdb7
17	17	text/concurrency \
18	18	text/parallelism \
	19	text/together \
	20	text/future \
19	21	}
20	22

doc/proposals/concurrency/annex/glossary.tex

r201aeb9	rd67cdb7
101	101	\newacronym{api}{API}{Application Program Interface}
102	102	\newacronym{raii}{RAII}{Ressource Acquisition Is Initialization}
	103	\newacronym{numa}{NUMA}{Non-Uniform Memory Access}

doc/proposals/concurrency/text/cforall.tex

-                      r201aeb9
+                      rd67cdb7
 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
 &r1 = x,    &&r2 = r1,   &&&r3 = r2;
 ***p3 = 3;                                      // change x
 r3 = 3;                                         // change x, ***r3
 **p3 = ...;                                     // change p1
 &r3 = ...;                                      // change r1, (&*)**r3
 *p3 = ...;                                      // change p2
 &&r3 = ...;                                     // change r2, (&(&*)*)*r3
 &&&r3 = p3;                                     // change r3 to p3, (&(&(&*)*)*)r3
 int y, z, & ar[3] = { x, y, z };                // initialize array of references
 &ar[1] = &z;                                    // change reference array element
 typeof( ar[1] ) p;                              // is int, i.e., the type of referenced object
 typeof( &ar[1] ) q;                             // is int &, i.e., the type of reference
 sizeof( ar[1] ) == sizeof( int );               // is true, i.e., the size of referenced object
 sizeof( &ar[1] ) == sizeof( int *);             // is true, i.e., the size of a reference
+***p3 = 3;                              // change x
+r3 = 3;                                 // change x, ***r3
+**p3 = ...;                             // change p1
+&r3 = ...;                              // change r1, (&*)**r3
+*p3 = ...;                              // change p2
+&&r3 = ...;                             // change r2, (&(&*)*)*r3
+&&&r3 = p3;                             // change r3 to p3, (&(&(&*)*)*)r3
+int y, z, & ar[3] = { x, y, z };        // initialize array of references
+&ar[1] = &z;                            // change reference array element
+typeof( ar[1] ) p;                      // is int, i.e., the type of referenced object
+typeof( &ar[1] ) q;                     // is int &, i.e., the type of reference
+sizeof( ar[1] ) == sizeof( int );       // is true, i.e., the size of referenced object
+sizeof( &ar[1] ) == sizeof( int *);     // is true, i.e., the size of a reference
 \end{cfacode}
 The important thing to take away from this code snippet is that references offer a handle to an object much like pointers but which is automatically derefferenced when convinient.
 …
 \begin{cfacode}
 // selection based on type and number of parameters
 void f( void );                                 // (1)
 void f( char );                                 // (2)
 void f( int, double );                          // (3)
 f();                                            // select (1)
 f( 'a' );                                       // select (2)
 f( 3, 5.2 );                                    // select (3)
+void f( void );                         // (1)
+void f( char );                         // (2)
+void f( int, double );                  // (3)
+f();                                    // select (1)
+f( 'a' );                               // select (2)
+f( 3, 5.2 );                            // select (3)
 // selection based on  type and number of returns
 char f( int );                                  // (1)
 double f( int );                                // (2)
 [ int, double ] f( int );                       // (3)
 char c = f( 3 );                                // select (1)
 double d = f( 4 );                              // select (2)
 [ int, double ] t = f( 5 );                     // select (3)
+char f( int );                          // (1)
+double f( int );                        // (2)
+[ int, double ] f( int );               // (3)
+char c = f( 3 );                        // select (1)
+double d = f( 4 );                      // select (2)
+[ int, double ] t = f( 5 );             // select (3)
 \end{cfacode}
 This feature is particularly important for concurrency since the runtime system relies on creating different types do represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent clashes. As seen in chapter \ref{basics}, the main is an example of routine that benefits from overloading when concurrency in introduced.
 …
 Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation would be, like so :
 \begin{cfacode}
 int ++?( int op );                              // unary prefix increment
 int ?++( int op );                              // unary postfix increment
 int ?+?( int op1, int op2 );                    // binary plus
 int ?<=?( int op1, int op2 );                   // binary less than
 int ?=?( int & op1, int op2 );                  // binary assignment
 int ?+=?( int & op1, int op2 );                 // binary plus-assignment
+int ++?( int op );                      // unary prefix increment
+int ?++( int op );                      // unary postfix increment
+int ?+?( int op1, int op2 );            // binary plus
+int ?<=?( int op1, int op2 );           // binary less than
+int ?=?( int & op1, int op2 );          // binary assignment
+int ?+=?( int & op1, int op2 );         // binary plus-assignment
 struct S { int i, j; };
 S ?+?( S op1, S op2 ) {                         // add two structures
+S ?+?( S op1, S op2 ) {                 // add two structures
         return (S){ op1.i + op2.i, op1.j + op2.j };
+}
 S s1 = { 1, 2 }, s2 = { 2, 3 }, s3;
 s3 = s1 + s2;                                   // compute sum: s3 == { 2, 5 }
+s3 = s1 + s2;                           // compute sum: s3 == { 2, 5 }
 \end{cfacode}
 …
 \section{Constructors/Destructors}
 \CFA uses the following syntax for constructors and destructors :
+Object life time is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object life time as a mean of synchronization and/or mutual exclusion. Since \CFA relies heavily on the life time of objects, Constructors \& Destructors are a the core of the features required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors :
 \begin{cfacode}
 struct S {
 …
         int * ia;
 };
 void ?{}( S & s, int asize ) with s {           // constructor operator
         size = asize;                           // initialize fields
+void ?{}( S & s, int asize ) with s {   // constructor operator
+        size = asize;                   // initialize fields
         ia = calloc( size, sizeof( S ) );
+}
 void ^?{}( S & s ) with s {                     // destructor operator
         free( ia );                             // de-initialization fields
+void ^?{}( S & s ) with s {             // destructor operator
+        free( ia );                     // de-initialization fields
+}
 int main() {
         S x = { 10 }, y = { 100 };              // implict calls: ?{}( x, 10 ), ?{}( y, 100 )
         ...                                     // use x and y
         ^x{};  ^y{};                            // explicit calls to de-initialize
         x{ 20 };  y{ 200 };                     // explicit calls to reinitialize
         ...                                     // reuse x and y
 }                                               // implict calls: ^?{}( y ), ^?{}( x )
+        S x = { 10 }, y = { 100 };      // implict calls: ?{}( x, 10 ), ?{}( y, 100 )
+        ...                             // use x and y
+        ^x{};  ^y{};                    // explicit calls to de-initialize
+        x{ 20 };  y{ 200 };             // explicit calls to reinitialize
+        ...                             // reuse x and y
+}                                       // implict calls: ^?{}( y ), ^?{}( x )
 \end{cfacode}
 The language guarantees that every object and all their fields are constructed. Like \CC construction is automatically done on declaration and destruction done when the declared variables reach the end of its scope.

doc/proposals/concurrency/text/concurrency.tex

-                      r201aeb9
+                      rd67cdb7
 int f5(graph(monitor*) & mutex m);
 \end{cfacode}
 The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed:
+The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To make the issue tractable, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed:
 \begin{cfacode}
 …
 % ======================================================================
 % ======================================================================
 There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system.
+There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem \cite{Chicken} of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system.
 The main memory concern for concurrency is queues. All blocking operations are made by parking threads onto queues. These queues need to be intrinsic\cit to avoid the need memory allocation. This entails that all the fields needed to keep track of all needed information. Since internal scheduling can use an unbound amount of memory (depending on \gls{group-acquire}) statically defining information information in the intrusive fields of threads is insufficient. The only variable sized container that does not require memory allocation is the callstack, which is heavily used in the implementation of internal scheduling. Particularly the GCC extension variable length arrays which is used extensively.
 …
 To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program.
+% ======================================================================
+% ======================================================================
+\section{Other concurrency tools}
+% ======================================================================
+% ======================================================================
+% \TODO
+\subsection{Internals}
+The complete mask can be pushed to any one, we are in a context where we already have full ownership of (at least) every concerned monitor and therefore monitors will refuse all calls no matter what.

doc/proposals/concurrency/text/intro.tex

-                      r201aeb9
+                      rd67cdb7
 % ======================================================================
 This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency, in \CFA. Indeed, for highly productive parallel programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adapted in \CFA
+This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency, in \CFA. Indeed, for highly productive concurrent programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adopted in \CFA
 There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the users. While these two concepts are often combined, they are in fact distinct concepts that require different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization.
+There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the programmers. While these two concepts are often combined, they are in fact distinct, requiring different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization.

doc/proposals/concurrency/text/parallelism.tex

-                      r201aeb9
+                      rd67cdb7
 \section{Paradigm}
 \subsection{User-level threads}
 A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading problems are hidden, users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
+A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensive costs of kernel threads. The down side is that almost none of the low-level threading problems are hidden; users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
 Examples of languages that support \glspl{uthread} are Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
 \subsection{Fibers : user-level threads without preemption}
 A popular varient of \glspl{uthread} is what is often reffered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers.
+A popular varient of \glspl{uthread} is what is often refered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial, and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers.
 An example of a language that uses fibers is Go~\cite{Go}
 \subsection{Jobs and thread pools}
 The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
+The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work, called jobs, and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
 The gold standard of this implementation is Intel's TBB library~\cite{TBB}.
 \subsection{Paradigm performance}
 While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead. However, interactions between jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches will be more expansive and the extra control means users need to tweak more variables to get the desired performance. Furthermore, if the units of uninterrupted work are large enough the paradigm choice is largely amorticised by the actual work done.
+While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead (i.e., not thread stack per job). However, interactions among jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches is more expansive and the extra control means users need to tweak more variables to get the desired performance. Finally, if the units of uninterrupted work are large enough the paradigm choice is largely amortised by the actual work done.
-\newpage
 \TODO
+\subsection{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel}
+\section{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel}
+\subsubsection{Future Work: Machine setup}\label{machine}
+While this was not done in the context of this proposal, another important aspect of clusters is affinity. While many common desktop and laptop PCs have homogeneous CPUs, other devices often have more heteregenous setups. For example, system using \acrshort{numa} configurations may benefit from users being able to tie clusters and/or kernel threads to certains CPU cores. OS support for CPU affinity is now common \cit, which means it is both possible and desirable for \CFA to offer an abstraction mechanism for portable CPU affinity.
 \subsection{Paradigms}\label{cfaparadigms}
+Given these building blocks we can then reproduce the all three of the popular paradigms. Indeed, we get \glspl{uthread} as the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application.
+% \subsection{High-level options}\label{tasks}
+%
+% \subsubsection{Thread interface}
+% constructors destructors
+%       initializer lists
+% monitors
+%
+% \subsubsection{Futures}
+%
+% \subsubsection{Implicit threading}
+% Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level.
+%
+% \begin{center}
+% \begin{tabular}[t]{|c|c|c|}
+% Sequential & System Parallel & Language Parallel \\
+% \begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       for(int i = 0; i < length; ++i ) {
+%               out[i] = a[i] + b[i];
+%       }
+% }
+%
+%
+%
+%
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting} &\begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       range ar(a, a + length);
+%       range br(b, b + length);
+%       range or(out, out + length);
+%       parfor( ai, bi, oi,
+%       [](int* ai, int* bi, int* oi) {
+%               oi = ai + bi;
+%       });
+% }
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting}&\begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       for (ai, bi, oi) in (a, b, out) {
+%               oi = ai + bi;
+%       }
+% }
+%
+%
+%
+%
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting}
+% \end{tabular}
+% \end{center}
+%
+% \subsection{Machine setup}\label{machine}
+% Threads are all good and well but wee still some OS support to fully utilize available hardware.
+%
+% \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads?
+Given these building blocks, it is possible to reproduce all three of the popular paradigms. Indeed, \glspl{uthread} is the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. Finally, it is possible to build executors for thread pools from \glspl{uthread} or \glspl{fiber}.

doc/proposals/concurrency/thesis.tex

-                      r201aeb9
+                      rd67cdb7
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
 % green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
 % LaTex escape §...§ (section symbol) emacs: C-q M-'
 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
+% inline code �...� (copyright symbol) emacs: C-q M-)
+% red highlighting �...� (registered trademark symbol) emacs: C-q M-.
+% blue highlighting �...� (sharp s symbol) emacs: C-q M-_
+% green highlighting �...� (cent symbol) emacs: C-q M-"
+% LaTex escape �...� (section symbol) emacs: C-q M-'
+% keyword escape �...� (pilcrow symbol) emacs: C-q M-^
 % math escape $...$ (dollar symbol)
 …
 \usepackage{multicol}
 \usepackage[acronym]{glossaries}
 \usepackage{varioref}
+\usepackage{varioref}
 \usepackage{listings}                                           % format program code
 \usepackage[flushmargin]{footmisc}                              % support label/reference in footnote
 …
 \input{parallelism}
+\chapter{Putting it all together}
+\input{together}
+\input{future}
 \chapter{Conclusion}
-\chapter{Future work}
-Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA.
-\subsection{Transactions}
 \section*{Acknowledgements}

doc/proposals/concurrency/version

r201aeb9	rd67cdb7
1		0.~~9.180~~
	1	0.10.2

src/CodeGen/CodeGenerator.cc

-                      r201aeb9
+                      rd67cdb7
         void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
                 extension( untypedExpr );
                 if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
+                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
                         OperatorInfo opInfo;
                         if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
                                 std::list< Expression* >::iterator arg = untypedExpr->get_args().begin();
+                        if ( operatorLookup( nameExpr->name, opInfo ) ) {
+                                std::list< Expression* >::iterator arg = untypedExpr->args.begin();
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
                                         assert( untypedExpr->get_args().size() == 2 );
+                                        assert( untypedExpr->args.size() == 2 );
                                         (*arg++)->accept( *visitor );
                                         output << "[";
 …
                                   case OT_CTOR:
                                   case OT_DTOR:
                                         if ( untypedExpr->get_args().size() == 1 ) {
+                                        if ( untypedExpr->args.size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor may contain side
                                                 // effects, so must still output this expression
 …
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo.symbol << "{ ";
                                                 genCommaList( arg, untypedExpr->get_args().end() );
+                                                genCommaList( arg, untypedExpr->args.end() );
                                                 output << "}) /* " << opInfo.inputName << " */";
                                         } // if
 …
                                   case OT_PREFIXASSIGN:
                                   case OT_LABELADDRESS:
                                         assert( untypedExpr->get_args().size() == 1 );
+                                        assert( untypedExpr->args.size() == 1 );
                                         output << "(";
                                         output << opInfo.symbol;
 …
                                   case OT_POSTFIX:
                                   case OT_POSTFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 1 );
+                                        assert( untypedExpr->args.size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo.symbol;
 …
                                   case OT_INFIX:
                                   case OT_INFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 2 );
+                                        assert( untypedExpr->args.size() == 2 );
                                         output << "(";
                                         (*arg++)->accept( *visitor );
 …
                                 } // switch
                         } else {
+                                if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
+                                        assert( untypedExpr->get_args().size() == 2 );
+                                        (*untypedExpr->get_args().begin())->accept( *visitor );
+                                        output << " ... ";
+                                        (*--untypedExpr->get_args().end())->accept( *visitor );
+                                } else {                                                                // builtin routines
+                                        nameExpr->accept( *visitor );
+                                        output << "(";
+                                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+                                        output << ")";
+                                } // if
+                                // builtin routines
+                                nameExpr->accept( *visitor );
+                                output << "(";
+                                genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
+                                output << ")";
                         } // if
                 } else {
                         untypedExpr->get_function()->accept( *visitor );
+                        untypedExpr->function->accept( *visitor );
                         output << "(";
                         genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+                        genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
                         output << ")";
                 } // if
 …
         void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
                 rangeExpr->get_low()->accept( *visitor );
+                rangeExpr->low->accept( *visitor );
                 output << " ... ";
                 rangeExpr->get_high()->accept( *visitor );
+                rangeExpr->high->accept( *visitor );
+        }
 …
         void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
+                updateLocation( caseStmt );
+                output << indent;
                 if ( caseStmt->isDefault()) {
                         output << "default";
 …
 } // namespace CodeGen
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
+        if ( node ) {
+                node->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/Concurrency/Keywords.cc

r201aeb9	rd67cdb7
528	528	DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
529	529	auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
530		~~// if( type ) std::cerr << "FRED2" << std::endl;~~
531	530	if( type && type->get_baseStruct()->is_thread() ) {
532	531	addStartStatement( decl, param );

src/Concurrency/Waitfor.cc

-                      r201aeb9
+                      rd67cdb7
 #include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
+#include "ResolvExpr/Resolver.h"   // for findVoidExpression
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
 …
         //=============================================================================================
         class GenerateWaitForPass final : public WithStmtsToAdd {
+        class GenerateWaitForPass final : public WithIndexer {
           public:
 …
                 ObjectDecl * declare( unsigned long count, CompoundStmt * stmt );
+                ObjectDecl * declareFlag( CompoundStmt * stmt );
+                Statement  * makeSetter( ObjectDecl * flag );
                 ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt );
                 void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt );
                 Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, CompoundStmt * stmt );
                 Expression * call();
                 void choose();
+                void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt );
+                Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt );
+                Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt);
+                void         choose( WaitForStmt * waitfor, Expression  * result, CompoundStmt * stmt );
                 static void implement( std::list< Declaration * > & translationUnit ) {
 …
           private:
                 FunctionDecl        * decl_waitfor    = nullptr;
+                StructDecl          * decl_mask       = nullptr;
                 StructDecl          * decl_acceptable = nullptr;
                 StructDecl          * decl_monitor    = nullptr;
-                DeclarationWithType * decl_m_func     = nullptr;
-                DeclarationWithType * decl_m_count    = nullptr;
-                DeclarationWithType * decl_m_monitors = nullptr;
-                DeclarationWithType * decl_m_isdtor   = nullptr;
                 static std::unique_ptr< Type > generic_func;
+                UniqueName namer_acc = "__acceptables_"s;
+                UniqueName namer_idx = "__index_"s;
+                UniqueName namer_flg = "__do_run_"s;
+                UniqueName namer_msk = "__mask_"s;
                 UniqueName namer_mon = "__monitors_"s;
-                UniqueName namer_acc = "__acceptables_"s;
                 UniqueName namer_tim = "__timeout_"s;
         };
 …
         namespace {
                 Expression * makeOpIndex( DeclarationWithType * array, unsigned long index ) {
                         return new ApplicationExpr(
+                        return new UntypedExpr(
                                 new NameExpr( "?[?]" ),
+                                {
 …
                 Expression * makeOpAssign( Expression * lhs, Expression * rhs ) {
                         return new ApplicationExpr(
+                        return new UntypedExpr(
                                         new NameExpr( "?=?" ),
                                         { lhs, rhs }
 …
+                }
+                Expression * makeOpMember( Expression * sue, DeclarationWithType * mem ) {
+                        return new MemberExpr( mem, sue );
+                }
+                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, DeclarationWithType * member, Expression * value ) {
+                        return new ExprStmt(
+                                noLabels,
+                                makeOpAssign(
+                                        makeOpMember(
+                                                makeOpIndex(
+                                                        object,
+                                                        index
+                                                ),
+                                                member
+                Expression * makeOpMember( Expression * sue, const std::string & mem ) {
+                        return new UntypedMemberExpr( new NameExpr( mem ), sue );
+                }
+                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
+                        std::unique_ptr< Expression > expr( makeOpAssign(
+                                makeOpMember(
+                                        makeOpIndex(
+                                                object,
+                                                index
                                         ),
+                                        value
+                                )
+                        );
+                                        member
+                                ),
+                                value
+                        ) );
+                        return new ExprStmt( noLabels, ResolvExpr::findVoidExpression( expr.get(), indexer ) );
+                }
 …
                         return new ConstantExpr( Constant::from_bool( ifnull ) );
+                }
+                VariableExpr * extractVariable( Expression * func ) {
+                        if( VariableExpr * var = dynamic_cast< VariableExpr * >( func ) ) {
+                                return var;
+                        }
+                        CastExpr * cast = strict_dynamic_cast< CastExpr * >( func );
+                        return strict_dynamic_cast< VariableExpr * >( cast->arg );
+                }
+                Expression * detectIsDtor( Expression * func ) {
+                        VariableExpr * typed_func = extractVariable( func );
+                        bool is_dtor = InitTweak::isDestructor( typed_func->var );
+                        return new ConstantExpr( Constant::from_bool( is_dtor ) );
+                }
         };
 …
         void GenerateWaitForPass::premutate( FunctionDecl * decl) {
                 if( decl->name != "__accept_internal" ) return;
+                if( decl->name != "__waitfor_internal" ) return;
                 decl_waitfor = decl;
 …
                         assert( !decl_acceptable );
                         decl_acceptable = decl;
+                        for( Declaration * field : decl_acceptable->members ) {
+                                     if( field->name == "func"    ) decl_m_func     = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "count"   ) decl_m_count    = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "is_dtor" ) decl_m_isdtor   = strict_dynamic_cast< DeclarationWithType * >( field );
+                        }
+                }
+                else if( decl->name == "__waitfor_mask_t" ) {
+                        assert( !decl_mask );
+                        decl_mask = decl;
+                }
                 else if( decl->name == "monitor_desc" ) {
 …
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
+                return waitfor;
+                if( !decl_monitor || !decl_acceptable ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
+                if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
                 CompoundStmt * stmt = new CompoundStmt( noLabels );
                 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
+                ObjectDecl * flag        = declareFlag( stmt );
+                Statement  * setter      = makeSetter( flag );
                 int index = 0;
                 for( auto & clause : waitfor->clauses ) {
                         init( acceptables, index, clause, stmt );
+                        init( acceptables, index, clause, setter, stmt );
                         index++;
 …
                         waitfor->orelse .statement,
                         waitfor->orelse .condition,
+                        setter,
                         stmt
                 );
+                // Expression * result  = call( acceptables, timeout, orelse, stmt );
+                // choose( waitfor, result );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                stmt->push_back( new IfStmt(
+                        noLabels,
+                        safeCond( new VariableExpr( flag ) ),
+                        compound,
+                        nullptr
+                ));
+                Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound );
+                choose( waitfor, result, compound );
                 return stmt;
 …
         ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt )
+        {
                 ObjectDecl * acceptables = new ObjectDecl(
+                ObjectDecl * acceptables = ObjectDecl::newObject(
                         namer_acc.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
 …
                 stmt->push_back( new DeclStmt( noLabels, acceptables) );
+                UntypedExpr * set = new UntypedExpr(
+                        new NameExpr( "__builtin_memset" ),
+                        {
+                                new VariableExpr( acceptables ),
+                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                new SizeofExpr( new VariableExpr( acceptables ) )
+                        }
+                );
+                Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer );
+                delete set;
+                stmt->push_back( new ExprStmt( noLabels, resolved_set ) );
                 return acceptables;
+        }
+        ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) {
+                ObjectDecl * flag = ObjectDecl::newObject(
+                        namer_flg.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::Bool
+                        ),
+                        new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) )
+                );
+                stmt->push_back( new DeclStmt( noLabels, flag) );
+                return flag;
+        }
+        Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
+                Expression * untyped = new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new VariableExpr( flag ),
+                                new ConstantExpr( Constant::from_ulong( 1 ) )
+                        }
+                );
+                Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer );
+                delete untyped;
+                return new ExprStmt( noLabels, expr );
+        }
         ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
                 ObjectDecl * mon = new ObjectDecl(
+                ObjectDecl * mon = ObjectDecl::newObject(
                         namer_mon.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
                                 new StructInstType(
+                                new PointerType(
                                         noQualifiers,
+                                        decl_monitor
+                                        new StructInstType(
+                                                noQualifiers,
+                                                decl_monitor
+                                        )
                                 ),
                                 new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ),
 …
                         new ListInit(
                                 map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
+                                        return new SingleInit( expr );
+                                        Expression * untyped = new CastExpr(
+                                                new UntypedExpr(
+                                                        new NameExpr( "get_monitor" ),
+                                                        { expr }
+                                                ),
+                                                new PointerType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_monitor
+                                                        )
+                                                )
+                                        );
+                                        Expression * init = ResolvExpr::findSingleExpression( untyped, indexer );
+                                        delete untyped;
+                                        return new SingleInit( init );
                                 })
+                        )
 …
+        }
         void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
+        void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) {
                 ObjectDecl * monitors = declMon( clause, stmt );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_func    , clause.target.function ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_count   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ) ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_monitors, new VariableExpr( monitors ) ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_isdtor  , new ConstantExpr( Constant::from_bool( true ) ) ) );
+                Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) );
                 stmt->push_back( new IfStmt(
                         noLabels,
                         safeCond( clause.condition ),
+                        compound,
+                        new CompoundStmt({
+                                makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
+                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
+                                makeAccStatement( acceptables, index, "list"   , new VariableExpr( monitors )                                              , indexer ),
+                                makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
+                                setter->clone()
+                        }),
                         nullptr
                 ));
 …
                 bool has_else,
                 Expression *& else_cond,
+                Statement * setter,
                 CompoundStmt * stmt
         ) {
                 ObjectDecl * timeout = new ObjectDecl(
+                ObjectDecl * timeout = ObjectDecl::newObject(
                         namer_tim.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new BasicType(
                                 noQualifiers,
 …
                         stmt->push_back( new IfStmt(
                                 noLabels,
+                                safeCond( else_cond ),
+                                new ExprStmt(
+                                        noLabels,
+                                        makeOpAssign(
+                                                new VariableExpr( timeout ),
+                                                time
+                                        )
+                                ),
+                                safeCond( time_cond ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        time
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
 …
                                 noLabels,
                                 safeCond( else_cond ),
+                                new ExprStmt(
+                                        noLabels,
+                                        makeOpAssign(
+                                                new VariableExpr( timeout ),
+                                                new ConstantExpr( Constant::from_ulong( 0 ) )
+                                        )
+                                ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        new ConstantExpr( Constant::from_ulong( 0 ) )
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
 …
+                }
+                delete setter;
                 return new VariableExpr( timeout );
+        }
+        Expression * GenerateWaitForPass::call(
+                size_t count,
+                ObjectDecl * acceptables,
+                Expression * timeout,
+                CompoundStmt * stmt
+        ) {
+                ObjectDecl * index = ObjectDecl::newObject(
+                        namer_idx.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::ShortSignedInt
+                        ),
+                        new SingleInit(
+                                new ConstantExpr( Constant::from_int( -1 ) )
+                        )
+                );
+                stmt->push_back( new DeclStmt( noLabels, index ) );
+                ObjectDecl * mask = ObjectDecl::newObject(
+                        namer_msk.newName(),
+                        new StructInstType(
+                                noQualifiers,
+                                decl_mask
+                        ),
+                        new ListInit({
+                                new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
+                                new SingleInit( new VariableExpr( acceptables ) ),
+                                new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
+                        })
+                );
+                stmt->push_back( new DeclStmt( noLabels, mask ) );
+                stmt->push_back( new ExprStmt(
+                        noLabels,
+                        new ApplicationExpr(
+                                VariableExpr::functionPointer( decl_waitfor ),
+                                {
+                                        new CastExpr(
+                                                new VariableExpr( mask ),
+                                                new ReferenceType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_mask
+                                                        )
+                                                )
+                                        ),
+                                        timeout
+                                }
+                        )
+                ));
+                return new VariableExpr( index );
+        }
+        void GenerateWaitForPass::choose(
+                WaitForStmt * waitfor,
+                Expression  * result,
+                CompoundStmt * stmt
+        ) {
+                SwitchStmt * swtch = new SwitchStmt(
+                        noLabels,
+                        result,
+                        std::list<Statement *>()
+                );
+                unsigned long i = 0;
+                for( auto & clause : waitfor->clauses ) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_ulong( i++ ) ),
+                                        {
+                                                clause.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                if(waitfor->timeout.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -2 ) ),
+                                        {
+                                                waitfor->timeout.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                if(waitfor->orelse.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -1 ) ),
+                                        {
+                                                waitfor->orelse.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                stmt->push_back( swtch );
+        }
 };

src/GenPoly/Box.cc

-                      r201aeb9
+                      rd67cdb7
 #include "Common/UniqueName.h"           // for UniqueName
 #include "Common/utility.h"              // for toString
-#include "DeclMutator.h"                 // for DeclMutator
 #include "FindFunction.h"                // for findFunction, findAndReplace...
 #include "GenPoly/ErasableScopedMap.h"   // for ErasableScopedMap<>::const_i...
 …
 #include "Lvalue.h"                      // for generalizedLvalue
 #include "Parser/LinkageSpec.h"          // for C, Spec, Cforall, Intrinsic
-#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
 #include "ResolvExpr/typeops.h"          // for typesCompatible
 …
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
+                class BoxPass {
+                protected:
+                        BoxPass() : scopeTyVars( TypeDecl::Data{} ) {}
+                        TyVarMap scopeTyVars;
+                };
                 /// Adds layout-generation functions to polymorphic types
                 class LayoutFunctionBuilder final : public DeclMutator {
                         unsigned int functionNesting;  // current level of nested functions
+                class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
+                        unsigned int functionNesting = 0;  // current level of nested functions
                 public:
+                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
+                        using DeclMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
+                        void previsit( FunctionDecl *functionDecl );
+                        void previsit( StructDecl *structDecl );
+                        void previsit( UnionDecl *unionDecl );
                 };
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 final : public PolyMutator {
+                class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
                   public:
                         Pass1();
+                        using PolyMutator::mutate;
+                        virtual Expression *mutate( ApplicationExpr *appExpr ) override;
+                        virtual Expression *mutate( AddressExpr *addrExpr ) override;
+                        virtual Expression *mutate( UntypedExpr *expr ) override;
+                        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual Expression *mutate( CommaExpr *commaExpr ) override;
+                        virtual Expression *mutate( ConditionalExpr *condExpr ) override;
+                        virtual Statement * mutate( ReturnStmt *returnStmt ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type * mutate( FunctionType *functionType ) override;
+                        virtual void doBeginScope() override;
+                        virtual void doEndScope() override;
+                        void premutate( FunctionDecl * functionDecl );
+                        void premutate( TypeDecl * typeDecl );
+                        void premutate( CommaExpr * commaExpr );
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                        Expression * postmutate( UntypedExpr *expr );
+                        void premutate( AddressExpr * addrExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
+                        void premutate( ReturnStmt * returnStmt );
+                        void premutate( PointerType * pointerType );
+                        void premutate( FunctionType * functionType );
+                        void beginScope();
+                        void endScope();
                   private:
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
 …
                 /// * Moves polymorphic returns in function types to pointer-type parameters
                 /// * adds type size and assertion parameters to parameter lists
+                class Pass2 final : public PolyMutator {
+                  public:
+                        template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl );
+                        template< typename AggDecl >
+                        AggDecl * handleAggDecl( AggDecl * aggDecl );
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual StructDecl *mutate( StructDecl *structDecl ) override;
+                        virtual UnionDecl *mutate( UnionDecl *unionDecl ) override;
+                        virtual TraitDecl *mutate( TraitDecl *unionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                struct Pass2 final : public BoxPass, public WithGuards {
+                        void handleAggDecl();
+                        DeclarationWithType * postmutate( FunctionDecl *functionDecl );
+                        void premutate( StructDecl *structDecl );
+                        void premutate( UnionDecl *unionDecl );
+                        void premutate( TraitDecl *unionDecl );
+                        void premutate( TypeDecl *typeDecl );
+                        void premutate( PointerType *pointerType );
+                        void premutate( FunctionType *funcType );
                   private:
 …
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
                 class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
+                class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
                 public:
                         PolyGenericCalculator();
 …
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
-                        TyVarMap scopeTyVars;
                 };
                 /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
+                class Pass3 final : public PolyMutator {
+                  public:
+                struct Pass3 final : public BoxPass, public WithGuards {
                         template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        using PolyMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                  private:
+                        void handleDecl( DeclClass * decl, Type * type );
+                        void premutate( ObjectDecl * objectDecl );
+                        void premutate( FunctionDecl * functionDecl );
+                        void premutate( TypedefDecl * typedefDecl );
+                        void premutate( StructDecl * structDecl );
+                        void premutate( UnionDecl * unionDecl );
+                        void premutate( TypeDecl * typeDecl );
+                        void premutate( PointerType * pointerType );
+                        void premutate( FunctionType * funcType );
                 };
         } // anonymous namespace
 …
         void box( std::list< Declaration *>& translationUnit ) {
                 LayoutFunctionBuilder layoutBuilder;
                 Pass1 pass1;
                 Pass2 pass2;
+                PassVisitor<LayoutFunctionBuilder> layoutBuilder;
+                PassVisitor<Pass1> pass1;
+                PassVisitor<Pass2> pass2;
                 PassVisitor<PolyGenericCalculator> polyCalculator;
                 Pass3 pass3;
                 layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
+                PassVisitor<Pass3> pass3;
+                acceptAll( translationUnit, layoutBuilder );
+                mutateAll( translationUnit, pass1 );
+                mutateAll( translationUnit, pass2 );
                 mutateAll( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
+                mutateAll( translationUnit, pass3 );
+        }
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
+        DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+        void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->get_functionType(), *visitor );
                 ++functionNesting;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                maybeAccept( functionDecl->get_statements(), *visitor );
                 --functionNesting;
-                return functionDecl;
+        }
 …
+        }
         Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
+        void LayoutFunctionBuilder::previsit( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
+                if ( structDecl->get_members().empty() ) return structDecl;
+                visit_children = false;
+                if ( structDecl->get_members().empty() ) return;
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() );
                 if ( otypeParams.empty() ) return structDecl;
+                if ( otypeParams.empty() ) return;
                 // build layout function signature
 …
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
+                addDeclarationAfter( layoutDecl );
+                return structDecl;
+                declsToAddAfter.push_back( layoutDecl );
+        }
         Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
+        void LayoutFunctionBuilder::previsit( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
+                if ( unionDecl->get_members().empty() ) return unionDecl;
+                visit_children = false;
+                if ( unionDecl->get_members().empty() ) return;
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
                 if ( otypeParams.empty() ) return unionDecl;
+                if ( otypeParams.empty() ) return;
                 // build layout function signature
 …
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
+                addDeclarationAfter( layoutDecl );
+                return unionDecl;
+                declsToAddAfter.push_back( layoutDecl );
+        }
 …
                 Pass1::Pass1() : tempNamer( "_temp" ) {}
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
+                void Pass1::premutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
+                                doBeginScope();
+                                scopeTyVars.beginScope();
+                                DeclarationWithType *oldRetval = retval;
+                                GuardScope( scopeTyVars );
+                                GuardValue( retval );
                                 // process polymorphic return value
                                 retval = nullptr;
+                                if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) {
+                                        retval = functionDecl->get_functionType()->get_returnVals().front();
+                                FunctionType *functionType = functionDecl->type;
+                                if ( isDynRet( functionType ) && functionDecl->linkage != LinkageSpec::C ) {
+                                        retval = functionType->returnVals.front();
                                         // give names to unnamed return values
                                         if ( retval->get_name() == "" ) {
                                                 retval->set_name( "_retparm" );
                                                 retval->set_linkage( LinkageSpec::C );
+                                        if ( retval->name == "" ) {
+                                                retval->name = "_retparm";
+                                                retval->linkage = LinkageSpec::C;
                                         } // if
                                 } // if
+                                FunctionType *functionType = functionDecl->get_functionType();
+                                makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
+                                std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
+                                makeTyVarMap( functionType, scopeTyVars );
+                                std::list< DeclarationWithType *> &paramList = functionType->parameters;
                                 std::list< FunctionType *> functions;
                                 for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                         for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
+                                for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) {
+                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
                                                 findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
                                         } // for
 …
                                         } // if
                                 } // for
-                                functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
-                                scopeTyVars.endScope();
-                                retval = oldRetval;
-                                doEndScope();
                                 // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
+                        return functionDecl;
+                }
+                TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
+                }
+                void Pass1::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+                Expression *Pass1::mutate( CommaExpr *commaExpr ) {
+                }
+                void Pass1::premutate( CommaExpr *commaExpr ) {
                         // Attempting to find application expressions that were mutated by the copy constructor passes
                         // to use an explicit return variable, so that the variable can be reused as a parameter to the
 …
+                                }
+                        }
-                        commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
-                        commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
-                        return commaExpr;
+                }
-                Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
-                        condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
-                        condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
-                        condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
-                        return condExpr;
+                }
 …
                 ObjectDecl *Pass1::makeTemporary( Type *type ) {
                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
                         stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
+                }
 …
                                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
                                         newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
                                         stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                                         UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
                                         assign->get_args().push_back( new VariableExpr( newObj ) );
                                         assign->get_args().push_back( arg );
                                         stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
+                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
                                         arg = new AddressExpr( new VariableExpr( newObj ) );
                                 } // if
 …
                                                 std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 adapter = answer.first;
                                                 stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
+                                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) );
                                         } // if
                                         assert( adapter != adapters.end() );
 …
+                }
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
+                Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
 …
                         // }
                         // std::cerr << "\n";
+                        appExpr->get_function()->acceptMutator( *this );
+                        mutateAll( appExpr->get_args(), *this );
+                        assert( appExpr->get_function()->has_result() );
+                        FunctionType * function = getFunctionType( appExpr->get_function()->get_result() );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() );
+                        assert( appExpr->function->result );
+                        FunctionType * function = getFunctionType( appExpr->function->result );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
 …
+                }
                 Expression *Pass1::mutate( UntypedExpr *expr ) {
                         if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
+                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                        if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
+                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
                                         if ( name->get_name() == "*?" ) {
                                                 Expression *ret = expr->get_args().front();
                                                 expr->get_args().clear();
+                                                Expression *ret = expr->args.front();
+                                                expr->args.clear();
                                                 delete expr;
                                                 return ret->acceptMutator( *this );
+                                                return ret;
                                         } // if
                                 } // if
                         } // if
+                        return PolyMutator::mutate( expr );
+                }
+                Expression *Pass1::mutate( AddressExpr *addrExpr ) {
+                        return expr;
+                }
+                void Pass1::premutate( AddressExpr * ) { visit_children = false; }
+                Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
                         assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
 …
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
+                        addrExpr->arg = addrExpr->get_arg()->acceptMutator( *visitor );
                         // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
 …
+                }
+                Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->get_expr() ) {
+                                assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
+                                delete returnStmt->get_expr();
+                                returnStmt->set_expr( 0 );
+                        } else {
+                                returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) );
+                void Pass1::premutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->expr ) {
+                                assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
+                                delete returnStmt->expr;
+                                returnStmt->expr = nullptr;
                         } // if
+                        return returnStmt;
+                }
+                Type * Pass1::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass1::premutate( PointerType *pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Mutator::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type * Pass1::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass1::premutate( FunctionType *functionType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
+                        Type *ret = Mutator::mutate( functionType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                void Pass1::doBeginScope() {
+                }
+                void Pass1::beginScope() {
                         adapters.beginScope();
+                }
                 void Pass1::doEndScope() {
+                void Pass1::endScope() {
                         adapters.endScope();
+                }
 …
+                }
+                template< typename DeclClass >
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
+                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
+                        return ret;
+                }
+                DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
+                        functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
+                DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) {
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
 …
+                }
+                ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl );
+                }
+                template< typename AggDecl >
+                AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) {
+                void Pass2::premutate( StructDecl * ) {
                         // prevent tyVars from leaking into containing scope
+                        scopeTyVars.beginScope();
+                        Parent::mutate( aggDecl );
+                        scopeTyVars.endScope();
+                        return aggDecl;
+                }
+                StructDecl * Pass2::mutate( StructDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                TraitDecl * Pass2::mutate( TraitDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( UnionDecl * ) {
+                        // prevent tyVars from leaking into containing scope
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( TraitDecl * ) {
+                        // prevent tyVars from leaking into containing scope
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        if ( typeDecl->get_base() ) {
+                                return handleDecl( typeDecl );
+                        } else {
+                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
+                        }
+                }
+                TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl );
+                }
+                Type * Pass2::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass2::premutate( PointerType *pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Parent::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type *Pass2::mutate( FunctionType *funcType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass2::premutate( FunctionType *funcType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( funcType, scopeTyVars );
 …
                                 // move all assertions into parameter list
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
-//      *assert = (*assert)->acceptMutator( *this );
                                         // assertion parameters may not be used in body, pass along with unused attribute.
                                         (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
 …
+                                                }
+                                        }
                                         seenTypes.insert( typeName );
+                                }
 …
                         funcType->get_parameters().splice( last, inferredParams );
                         addAdapters( funcType );
-                        mutateAll( funcType->get_returnVals(), *this );
-                        mutateAll( funcType->get_parameters(), *this );
-                        scopeTyVars.endScope();
-                        return funcType;
+                }
 …
                 PolyGenericCalculator::PolyGenericCalculator()
                         : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
+                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
                 void PolyGenericCalculator::beginTypeScope( Type *ty ) {
 …
                 template< typename DeclClass >
                 DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
                         scopeTyVars.beginScope();
+                void Pass3::handleDecl( DeclClass * decl, Type * type ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( type, scopeTyVars );
-                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
-                        // ScrubTyVars::scrub( decl, scopeTyVars );
                         ScrubTyVars::scrubAll( decl );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                ObjectDecl * Pass3::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl, objectDecl->get_type() );
+                }
+                DeclarationWithType * Pass3::mutate( FunctionDecl *functionDecl ) {
+                        return handleDecl( functionDecl, functionDecl->get_functionType() );
+                }
+                TypedefDecl * Pass3::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl, typedefDecl->get_base() );
+                }
+                void Pass3::premutate( ObjectDecl * objectDecl ) {
+                        handleDecl( objectDecl, objectDecl->type );
+                }
+                void Pass3::premutate( FunctionDecl * functionDecl ) {
+                        handleDecl( functionDecl, functionDecl->type );
+                }
+                void Pass3::premutate( TypedefDecl * typedefDecl ) {
+                        handleDecl( typedefDecl, typedefDecl->base );
+                }
                 /// Strips the members from a generic aggregate
                 void stripGenericMembers(AggregateDecl* decl) {
                         if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
+                }
                 Declaration *Pass3::mutate( StructDecl *structDecl ) {
+                void stripGenericMembers(AggregateDecl * decl) {
+                        if ( ! decl->parameters.empty() ) decl->members.clear();
+                }
+                void Pass3::premutate( StructDecl * structDecl ) {
                         stripGenericMembers( structDecl );
+                        return structDecl;
+                }
+                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
+                }
+                void Pass3::premutate( UnionDecl * unionDecl ) {
                         stripGenericMembers( unionDecl );
+                        return unionDecl;
+                }
+                TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
+//   Initializer *init = 0;
+//   std::list< Expression *> designators;
+//   addToTyVarMap( typeDecl, scopeTyVars );
+//   if ( typeDecl->get_base() ) {
+//     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
+//   }
+//   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
+                }
+                void Pass3::premutate( TypeDecl * typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+                Type * Pass3::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass3::premutate( PointerType * pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Mutator::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type * Pass3::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass3::premutate( FunctionType * functionType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
-                        Type *ret = Mutator::mutate( functionType );
-                        scopeTyVars.endScope();
-                        return ret;
+                }
         } // anonymous namespace

src/GenPoly/Specialize.cc

-                      r201aeb9
+                      rd67cdb7
 #include <utility>                       // for pair
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
 …
 #include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
 #include "Parser/LinkageSpec.h"          // for C
-#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
 …
 namespace GenPoly {
+        class Specialize final : public PolyMutator {
+          public:
+                using PolyMutator::mutate;
+                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
+                virtual Expression * mutate( AddressExpr *castExpr ) override;
+                virtual Expression * mutate( CastExpr *castExpr ) override;
+                // virtual Expression * mutate( LogicalExpr *logicalExpr );
+                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
+                // virtual Expression * mutate( CommaExpr *commaExpr );
+        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+                Expression * postmutate( ApplicationExpr *applicationExpr );
+                Expression * postmutate( AddressExpr *castExpr );
+                Expression * postmutate( CastExpr *castExpr );
                 void handleExplicitParams( ApplicationExpr *appExpr );
 …
+        }
         struct EnvTrimmer : public Visitor {
+        struct EnvTrimmer {
                 TypeSubstitution * env, * newEnv;
                 EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 virtual void visit( TypeDecl * tyDecl ) {
+                void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
                         if ( Type * t = env->lookup( tyDecl->get_name() ) ) {
                                 newEnv->add( tyDecl->get_name(), t );
+                        if ( Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
+                        }
+                }
 …
                 if ( env ) {
                         TypeSubstitution * newEnv = new TypeSubstitution();
                         EnvTrimmer trimmer( env, newEnv );
+                        PassVisitor<EnvTrimmer> trimmer( env, newEnv );
                         expr->accept( trimmer );
                         return newEnv;
 …
                 std::string oldParamPrefix = paramPrefix;
                 paramPrefix += "p";
                 // save stmtsToAdd in oldStmts
+                // save stmtsToAddBefore in oldStmts
                 std::list< Statement* > oldStmts;
                 oldStmts.splice( oldStmts.end(), stmtsToAdd );
                 mutate( appExpr );
+                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
+                appExpr->acceptMutator( *visitor );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
                 thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd );
                 // restore oldStmts into stmtsToAdd
                 stmtsToAdd.splice( stmtsToAdd.end(), oldStmts );
+                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
+                // restore oldStmts into stmtsToAddBefore
+                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
                 // add return (or valueless expression) to the thunk
                 Statement *appStmt;
                 if ( funType->get_returnVals().empty() ) {
+                if ( funType->returnVals.empty() ) {
                         appStmt = new ExprStmt( noLabels, appExpr );
                 } else {
                         appStmt = new ReturnStmt( noLabels, appExpr );
                 } // if
                 thunkFunc->get_statements()->get_kids().push_back( appStmt );
+                thunkFunc->statements->kids.push_back( appStmt );
                 // add thunk definition to queue of statements to add
                 stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
+                stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );
 …
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
                 assert( appExpr->get_function()->has_result() );
                 FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                assert( appExpr->function->result );
+                FunctionType *function = getFunctionType( appExpr->function->result );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
+                        *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+        Expression * Specialize::mutate( ApplicationExpr *appExpr ) {
+                appExpr->get_function()->acceptMutator( *this );
+                mutateAll( appExpr->get_args(), *this );
+                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+        Expression * Specialize::postmutate( ApplicationExpr *appExpr ) {
                 if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) {
                         // create thunks for the inferred parameters
 …
+        }
+        Expression * Specialize::mutate( AddressExpr *addrExpr ) {
+                addrExpr->get_arg()->acceptMutator( *this );
+                assert( addrExpr->has_result() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+        Expression * Specialize::postmutate( AddressExpr *addrExpr ) {
+                assert( addrExpr->result );
+                addrExpr->set_arg( doSpecialization( addrExpr->result, addrExpr->arg ) );
                 return addrExpr;
+        }
+        Expression * Specialize::mutate( CastExpr *castExpr ) {
+                castExpr->get_arg()->acceptMutator( *this );
+                if ( castExpr->get_result()->isVoid() ) {
+        Expression * Specialize::postmutate( CastExpr *castExpr ) {
+                if ( castExpr->result->isVoid() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
+                }
                 Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
+                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg );
+                if ( specialized != castExpr->arg ) {
                         // assume here that the specialization incorporates the cast
                         return specialized;
 …
+        }
-        // Removing these for now. Richard put these in for some reason, but it's not clear why.
-        // In particular, copy constructors produce a comma expression, and with this code the parts
-        // of that comma expression are not specialized, which causes problems.
-        // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
-        //      return logicalExpr;
-        // }
-        // Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
-        //      return condExpr;
-        // }
-        // Expression * Specialize::mutate( CommaExpr *commaExpr ) {
-        //      return commaExpr;
-        // }
         void convertSpecializations( std::list< Declaration* >& translationUnit ) {
                 Specialize spec;
+                PassVisitor<Specialize> spec;
                 mutateAll( translationUnit, spec );
+        }

src/GenPoly/module.mk

-                      r201aeb9
+                      rd67cdb7
 ## file "LICENCE" distributed with Cforall.
 ##
 ## module.mk --
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
 …
 SRC += GenPoly/Box.cc \
        GenPoly/GenPoly.cc \
-       GenPoly/PolyMutator.cc \
        GenPoly/ScrubTyVars.cc \
        GenPoly/Lvalue.cc \
 …
        GenPoly/CopyParams.cc \
        GenPoly/FindFunction.cc \
-       GenPoly/DeclMutator.cc \
        GenPoly/InstantiateGeneric.cc

src/InitTweak/FixInit.cc

-                      r201aeb9
+                      rd67cdb7
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
-#include "GenPoly/DeclMutator.h"       // for DeclMutator
 #include "GenPoly/GenPoly.h"           // for getFunctionType
-#include "GenPoly/PolyMutator.h"       // for PolyMutator
 #include "InitTweak.h"                 // for getFunctionName, getCallArg
 #include "Parser/LinkageSpec.h"        // for C, Spec, Cforall, isBuiltin
 …
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
-#include "SynTree/AddStmtVisitor.h"    // for AddStmtVisitor
 #include "SynTree/Attribute.h"         // for Attribute
 #include "SynTree/Constant.h"          // for Constant
 …
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
-#include "Tuples/Tuples.h"             // for isTtype
 bool ctordtorp = false; // print all debug
 …
                 };
                 class FixCopyCtors final : public GenPoly::PolyMutator {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
 …
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
+                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void premutate( StmtExpr * stmtExpr );
+                        void premutate( UniqueExpr * unqExpr );
                         UnqCount & unqCount;
 …
                 };
+                class FixCtorExprs final : public GenPoly::DeclMutator {
+                  public:
+                struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer {
                         /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
                         static void fix( std::list< Declaration * > & translationUnit );
+                        using GenPoly::DeclMutator::mutate;
+                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
+                        Expression * postmutate( ConstructorExpr * ctorExpr );
                 };
         } // namespace
 …
                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
                         FixCopyCtors fixer( unqCount );
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         mutateAll( translationUnit, fixer );
+                }
 …
                 void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) {
                         FixCtorExprs fixer;
                         fixer.mutateDeclarationList( translationUnit );
+                        PassVisitor<FixCtorExprs> fixer;
+                        mutateAll( translationUnit, fixer );
+                }
 …
                                 } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
+                                        assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
                                         if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
 …
+                }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); }
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
 …
                         result = result->clone();
                         env->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
                         tmp->get_type()->set_const( false );
 …
                                 if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
+                        }
+                        // set a unique name for the temporary once it's certain the call is necessary
+                        tmp->name = tempNamer.newName();
                         // replace argument to function call with temporary
 …
                                 result = result->clone();
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
                                 ret->get_type()->set_const( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
+                                        // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
+                                }
 …
                                 result = result->clone();
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
                                 ret->get_type()->set_const( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
 …
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
                                 unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), nullptr ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
+                        }
 …
+                }
                 Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
-                        impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
 …
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
                                 stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
                                 stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 …
                         } // for
-                        // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
 …
+                }
                 Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
+                void FixCopyCtors::premutate( StmtExpr * stmtExpr ) {
                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
                         // since temporaries can be shared across sub-expressions, e.g.
                         //   [A, A] f();
                         //   g([A] x, [A] y);
                         //   f(g());
+                        //   g(f());
                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
+                        // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added
+                        // to the outer context, rather than inside of the statement expression.
+                        visit_children = false;
                         std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                         for ( Statement *& stmt : stmts ) {
                                 stmt = stmt->acceptMutator( *this );
+                                stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
                                         stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
 …
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
+                                CompoundStmt * body = stmtExpr->get_statements();
+                                assert( ! body->get_kids().empty() );
+                                assert( ! stmts.empty() );
                                 assert( ! stmtExpr->get_returnDecls().empty() );
                                 body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
 …
                         assert( stmtExpr->get_returnDecls().empty() );
                         assert( stmtExpr->get_dtors().empty() );
                         return stmtExpr;
+                }
                 Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
+                }
+                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
+                        visit_children = false;
                         unqCount[ unqExpr->get_id() ]--;
                         static std::unordered_map< int, std::list< Statement * > > dtors;
                         static std::unordered_map< int, UniqueExpr * > unqMap;
-                        static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
                         if ( unqMap.count( unqExpr->get_id() ) ) {
 …
                                         stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
+                                }
+                                if ( addDeref.count( unqExpr->get_id() ) ) {
+                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
+                                        return UntypedExpr::createDeref( unqExpr );
+                                }
+                                return unqExpr;
+                        }
+                        FixCopyCtors fixer( unqCount );
+                                return;
+                        }
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
                         stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
+                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
                                 stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                         } else { // remember dtors for last instance of unique expr
+                                dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
+                        }
+                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
+                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
+                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
+                                // (i.e. move the dereference out a level)
+                                assert( getFunctionName( deref ) == "*?" );
+                                unqExpr->set_expr( getCallArg( deref, 0 ) );
+                                getCallArg( deref, 0 ) = unqExpr;
+                                addDeref.insert( unqExpr->get_id() );
+                                return deref;
+                        }
+                        return unqExpr;
+                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
+                        }
+                        return;
+                }
 …
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
+                                        // don't need to call intrinsic dtor, because it does nothing, but
+                                        // non-intrinsic dtors must be called
                                         if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
                                                 // don't need to call intrinsic dtor, because it does nothing, but
                                                 // non-intrinsic dtors must be called
+                                                // set dtor location to the object's location for error messages
+                                                ctorInit->dtor->location = objDecl->location;
                                                 reverseDeclOrder.front().push_front( objDecl );
                                         } // if
 …
                                         // skip non-DWT members
                                         if ( ! field ) continue;
+                                        // skip non-constructable members
+                                        if ( ! tryConstruct( field ) ) continue;
                                         // skip handled members
                                         if ( ! unhandled.count( field ) ) continue;
 …
+                }
                 Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
+                Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
 …
                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
                         addDeclaration( tmp );
+                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
+                        declsToAddBefore.push_back( tmp );
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
 …
                         delete ctorExpr;
+                        // build assignment and replace constructor's first argument with new temporary
                         Expression *& firstArg = callExpr->get_args().front();
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
+                        Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } );
                         firstArg = new VariableExpr( tmp );
+                        // resolve assignment and dispose of new env
+                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
+                        delete resolvedAssign->env;
+                        resolvedAssign->env = nullptr;
+                        delete assign;
                         // for constructor expr:
 …
                         //   T & tmp;
                         //   &tmp = &x, ?{}(tmp), tmp
                         CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
+                        CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
                         return commaExpr;

src/InitTweak/GenInit.cc

-                      r201aeb9
+                      rd67cdb7
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for ValueGuard, maybeClone
-#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/GenPoly.h"       // for getFunctionType, isPolyType
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::const_iter...
 …
         };
         struct CtorDtor : public WithGuards, public WithShortCircuiting  {
+        struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
 …
                 // that need to be constructed or destructed
                 void previsit( StructDecl *aggregateDecl );
+                void previsit( __attribute__((unused)) UnionDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) EnumDecl     * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TraitDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TypeDecl     * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) TypedefDecl  * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) FunctionType * funcType )      { visit_children = false; }
+                void previsit( AggregateDecl * ) { visit_children = false; }
+                void previsit( NamedTypeDecl * ) { visit_children = false; }
+                void previsit( FunctionType * ) { visit_children = false; }
                 void previsit( CompoundStmt * compoundStmt );
 …
         };
+        class HoistArrayDimension final : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
                 /// hoist dimension from array types in object declaration so that it uses a single
                 /// const variable of type size_t, so that side effecting array dimensions are only
 …
                 static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
+          private:
+                using Parent::mutate;
+                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                void premutate( ObjectDecl * objectDecl );
+                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
+                void premutate( FunctionDecl *functionDecl );
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
+                virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
+                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
+                virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
+                void premutate( AggregateDecl * ) { visit_children = false; }
+                void premutate( NamedTypeDecl * ) { visit_children = false; }
+                void premutate( FunctionType * ) { visit_children = false; }
                 void hoist( Type * type );
 …
         void genInit( std::list< Declaration * > & translationUnit ) {
                 ReturnFixer::makeReturnTemp( translationUnit );
+                fixReturnStatements( translationUnit );
                 HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
+        }
         void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
+        void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
 …
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
                 if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
                         assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
 …
                 GuardValue( funcName );
                 ftype = functionDecl->get_functionType();
                 funcName = functionDecl->get_name();
+                ftype = functionDecl->type;
+                funcName = functionDecl->name;
+        }
 …
         // which would be incorrect if it is a side-effecting computation.
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
+                HoistArrayDimension hoister;
+                hoister.mutateDeclarationList( translationUnit );
+        }
+        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
+                PassVisitor<HoistArrayDimension> hoister;
+                mutateAll( translationUnit, hoister );
+        }
+        void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
+                GuardValue( storageClasses );
                 storageClasses = objectDecl->get_storageClasses();
+                DeclarationWithType * temp = Parent::mutate( objectDecl );
+        }
+        DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
                 hoist( objectDecl->get_type() );
                 return temp;
+                return objectDecl;
+        }
 …
                         arrayType->set_dimension( new VariableExpr( arrayDimension ) );
                         addDeclaration( arrayDimension );
+                        declsToAddBefore.push_back( arrayDimension );
                         hoist( arrayType->get_base() );
 …
+        }
+        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc( inFunction );
+                inFunction = true;
+                DeclarationWithType * decl = Parent::mutate( functionDecl );
+                return decl;
+        void HoistArrayDimension::premutate( FunctionDecl * ) {
+                GuardValue( inFunction );
+        }
 …
         bool CtorDtor::isManaged( Type * type ) const {
                 // at least for now, references are never constructed
+                // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
 …
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
                         // tuple is also managed if any of its components are managed
                         if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
+                        if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
                                 return true;
+                        }
 …
         void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;  // do not try and construct parameters or forall parameters
                 GuardValue( inFunction );
                 inFunction = true;
 …
+                }
+                PassVisitor<CtorDtor> newCtorDtor;
+                newCtorDtor.pass = *this;
+                maybeAccept( functionDecl->get_statements(), newCtorDtor );
+                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+                maybeAccept( functionDecl->get_statements(), *visitor );
+        }
 …
+        }
         void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) {
+        void CtorDtor::previsit( CompoundStmt * ) {
                 GuardScope( managedTypes );
+        }

src/InitTweak/GenInit.h

-                      r201aeb9
+                      rd67cdb7
         void genInit( std::list< Declaration * > & translationUnit );
+  /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+  ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+        /// Converts return statements into copy constructor calls on the hidden return variable
+        void fixReturnStatements( std::list< Declaration * > & translationUnit );
+        /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer

src/InitTweak/InitTweak.cc

-                      r201aeb9
+                      rd67cdb7
-#include <stddef.h>                // for NULL
 #include <algorithm>               // for find, all_of
 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
 …
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
 #include "SynTree/Visitor.h"       // for Visitor, maybeAccept
+#include "Tuples/Tuples.h"         // for Tuples::isTtype
 class UntypedValofExpr;
 …
                         callExpr->get_args().splice( callExpr->get_args().end(), args );
                         *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL );
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
 …
         // To accomplish this, generate switch statement, consuming all of expander's elements
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return NULL;
+                if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
                 if ( block->get_kids().empty() ) {
                         delete block;
                         return NULL;
+                        return nullptr;
                 } else {
                         init = NULL; // init was consumed in creating the list init
+                        init = nullptr; // init was consumed in creating the list init
                         return block;
+                }
+        }
         Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
                 return NULL;
+        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+                return nullptr;
+        }
 …
+        }
+        bool tryConstruct( ObjectDecl * objDecl ) {
+        bool tryConstruct( DeclarationWithType * dwt ) {
+                ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
+                        (objDecl->get_init() == NULL ||
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern;
+                        (objDecl->get_init() == nullptr ||
+                                ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern
+                        && isConstructable( objDecl->type );
+        }
+        bool isConstructable( Type * type ) {
+                return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
 …
                 collectCtorDtorCalls( stmt, matches );
                 assert( matches.size() <= 1 );
                 return matches.size() == 1 ? matches.front() : NULL;
+                return matches.size() == 1 ? matches.front() : nullptr;
+        }
 …
         ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) {
                 ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
                 if ( ! appExpr ) return NULL;
+                if ( ! appExpr ) return nullptr;
                 DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
                 assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() );
                 // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
                 // will call all member dtors, and some members may have a user defined dtor.
                 return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
+                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr;
+        }
 …
                         return refType->get_base();
                 } else {
                         return NULL;
+                        return nullptr;
+                }
+        }
 …
         Type * isPointerType( Type * type ) {
                 if ( getPointerBase( type ) ) return type;
                 else return NULL;
+                else return nullptr;
+        }

src/InitTweak/InitTweak.h

-                      r201aeb9
+                      rd67cdb7
         std::list< Expression * > makeInitList( Initializer * init );
+        /// True if the resolver should try to construct objDecl
+        bool tryConstruct( ObjectDecl * objDecl );
+        /// True if the resolver should try to construct dwt
+        bool tryConstruct( DeclarationWithType * dwt );
+        /// True if the type can have a user-defined constructor
+        bool isConstructable( Type * t );
         /// True if the Initializer contains designations

src/Makefile.in

-                      r201aeb9
+                      rd67cdb7
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) \
 …
         GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \
         InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \
 …
         SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \
-        SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
 …
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
+        GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
+        GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
+        GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
+        GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \
+        GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \
+        GenPoly/Specialize.cc GenPoly/CopyParams.cc \
+        GenPoly/FindFunction.cc GenPoly/InstantiateGeneric.cc \
         InitTweak/GenInit.cc InitTweak/FixInit.cc \
         InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \
 …
         SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
         SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
         SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
         Tuples/Explode.cc Virtual/ExpandCasts.cc
+        SynTree/TypeSubstitution.cc SynTree/Attribute.cc \
+        SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc Tuples/Explode.cc \
+        Virtual/ExpandCasts.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
 …
 GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 …
 GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
 …
 SynTree/driver_cfa_cpp-Mutator.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT):  \
-        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Specialize.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AggregateDecl.Po@am__quote@
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-GenPoly.obj `if test -f 'GenPoly/GenPoly.cc'; then $(CYGPATH_W) 'GenPoly/GenPoly.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/GenPoly.cc'; fi`
-GenPoly/driver_cfa_cpp-PolyMutator.o: GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
-GenPoly/driver_cfa_cpp-PolyMutator.obj: GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
 GenPoly/driver_cfa_cpp-ScrubTyVars.o: GenPoly/ScrubTyVars.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-ScrubTyVars.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Tpo -c -o GenPoly/driver_cfa_cpp-ScrubTyVars.o `test -f 'GenPoly/ScrubTyVars.cc' || echo '$(srcdir)/'`GenPoly/ScrubTyVars.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi`
-GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
-GenPoly/driver_cfa_cpp-DeclMutator.obj: GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
 GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Mutator.obj `if test -f 'SynTree/Mutator.cc'; then $(CYGPATH_W) 'SynTree/Mutator.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Mutator.cc'; fi`
-SynTree/driver_cfa_cpp-AddStmtVisitor.o: SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
-SynTree/driver_cfa_cpp-AddStmtVisitor.obj: SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
 SynTree/driver_cfa_cpp-TypeSubstitution.o: SynTree/TypeSubstitution.cc

src/Parser/StatementNode.cc

-                      r201aeb9
+                      rd67cdb7
                 target,
                 maybeMoveBuild<Statement >( stmt ),
                 maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 …
         delete targetExpr;
         node->clauses.push_back( WaitForStmt::Clause{
+        node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
                 std::move( target ),
                 maybeMoveBuild<Statement >( stmt ),
                 maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 …
                 node->timeout.time      = maybeMoveBuild<Expression>( timeout );
                 node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
                 node->timeout.condition = maybeMoveBuild<Expression>( when    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        }
         else {
                 node->orelse.statement  = maybeMoveBuild<Statement >( stmt    );
                 node->orelse.condition  = maybeMoveBuild<Expression>( when    );
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        }
 …
         node->timeout.time      = maybeMoveBuild<Expression>( timeout );
         node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
         node->timeout.condition = maybeMoveBuild<Expression>( when    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
         node->orelse.statement = maybeMoveBuild<Statement >( else_stmt );
         node->orelse.condition = maybeMoveBuild<Expression>( else_when );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
         return node;
+}
-// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) {
-//       return WaitForStmt::Clause{
-//       };
-// }
 Statement *build_compound( StatementNode *first ) {

src/Parser/parserutility.cc

r201aeb9	rd67cdb7
29	29
30	30	Expression notZeroExpr( Expression orig ) {
	31	if( !orig ) return nullptr;
31	32	UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
32	33	comparison->get_args().push_back( orig );

src/ResolvExpr/AlternativeFinder.cc

-                      r201aeb9
+                      rd67cdb7
                         expr->get_result()->accept( global_renamer );
+                }
-                void referenceToRvalueConversion( Expression *& expr ) {
-                        if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
-                                // cast away reference from expr
-                                expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                        }
+                }
         } // namespace
+        void referenceToRvalueConversion( Expression *& expr ) {
+                if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                        // cast away reference from expr
+                        expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                }
+        }
         template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/AlternativeFinder.h

-                      r201aeb9
+                      rd67cdb7
                 const SymTab::Indexer &get_indexer() const { return indexer; }
                 const TypeEnvironment &get_environ() const { return env; }
+                /// Runs a new alternative finder on each element in [begin, end)
+                /// and writes each alternative finder to out.
+                template< typename InputIterator, typename OutputIterator >
+                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
           private:
                 virtual void visit( ApplicationExpr *applicationExpr );
 …
                 virtual void visit( StmtExpr *stmtExpr );
                 virtual void visit( UntypedInitExpr *initExpr );
-                /// Runs a new alternative finder on each element in [begin, end)
-                /// and writes each alternative finder to out.
-                template< typename InputIterator, typename OutputIterator >
-                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
                 /// Adds alternatives for anonymous members
 …
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
+        void referenceToRvalueConversion( Expression *& expr );
         template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/Resolver.cc

-                      r201aeb9
+                      rd67cdb7
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
 using namespace std;
 …
                 void previsit( ThrowStmt *throwStmt );
                 void previsit( CatchStmt *catchStmt );
+                void previsit( WaitForStmt * stmt );
                 void previsit( SingleInit *singleInit );
 …
                 PassVisitor<Resolver> resolver;
                 acceptAll( translationUnit, resolver );
+        }
+        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
+                PassVisitor<Resolver> resolver( indexer );
+                maybeAccept( decl, resolver );
+        }
 …
+        }
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                TypeEnvironment env;
+                AlternativeFinder finder( indexer, env );
+                finder.find( untyped );
+                #if 0
+                if ( finder.get_alternatives().size() != 1 ) {
+                        std::cout << "untyped expr is ";
+                        untyped->print( std::cout );
+                        std::cout << std::endl << "alternatives are:";
+                        for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
+                                i->print( std::cout );
+                        } // for
+                } // if
+                #endif
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                Alternative &choice = finder.get_alternatives().front();
+                Expression *newExpr = choice.expr->clone();
+                finishExpr( newExpr, choice.env );
+                return newExpr;
+        }
         namespace {
-                Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
-                        Alternative &choice = finder.get_alternatives().front();
-                        Expression *newExpr = choice.expr->clone();
-                        finishExpr( newExpr, choice.env );
-                        return newExpr;
+                }
                 bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
 …
+        }
+        inline void resolveAsIf( Expression *& expr, SymTab::Indexer & indexer ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( expr, indexer );
+                delete expr;
+                expr = newExpr;
+        }
+        inline void resolveAsType( Expression *& expr, Type * type, SymTab::Indexer & indexer ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), indexer );
+                delete expr;
+                expr = newExpr;
+        }
+        template< typename iterator_t >
+        inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
+                while( it != end && !(*it)->get_type()->get_mutex() ) {
+                        it++;
+                }
+                return it != end;
+        }
+        void Resolver::previsit( WaitForStmt * stmt ) {
+                visit_children = false;
+                // Resolve all clauses first
+                for( auto& clause : stmt->clauses ) {
+                        TypeEnvironment env;
+                        AlternativeFinder funcFinder( indexer, env );
+                        // Find all alternatives for a function in canonical form
+                        funcFinder.findWithAdjustment( clause.target.function );
+                        if ( funcFinder.get_alternatives().empty() ) {
+                                stringstream ss;
+                                ss << "Use of undeclared indentifier '";
+                                ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
+                                ss << "' in call to waitfor";
+                                throw SemanticError( ss.str() );
+                        }
+                        // Find all alternatives for all arguments in canonical form
+                        std::list< AlternativeFinder > argAlternatives;
+                        funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
+                        // List all combinations of arguments
+                        std::list< AltList > possibilities;
+                        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+                        AltList                func_candidates;
+                        std::vector< AltList > args_candidates;
+                        // For every possible function :
+                        //      try matching the arguments to the parameters
+                        //      not the other way around because we have more arguments than parameters
+                        SemanticError errors;
+                        for ( Alternative & func : funcFinder.get_alternatives() ) {
+                                try {
+                                        PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
+                                        if( !pointer ) {
+                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                        }
+                                        FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                                        if( !function ) {
+                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                        }
+                                        {
+                                                auto param     = function->parameters.begin();
+                                                auto param_end = function->parameters.end();
+                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                }
+                                        }
+                                        Alternative newFunc( func );
+                                        // Strip reference from function
+                                        referenceToRvalueConversion( newFunc.expr );
+                                        // For all the set of arguments we have try to match it with the parameter of the current function alternative
+                                        for ( auto & argsList : possibilities ) {
+                                                try {
+                                                        // Declare data structures need for resolution
+                                                        OpenVarSet openVars;
+                                                        AssertionSet resultNeed, resultHave;
+                                                        TypeEnvironment resultEnv;
+                                                        // Load type variables from arguemnts into one shared space
+                                                        simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
+                                                        // Make sure we don't widen any existing bindings
+                                                        for ( auto & i : resultEnv ) {
+                                                                i.allowWidening = false;
+                                                        }
+                                                        // Find any unbound type variables
+                                                        resultEnv.extractOpenVars( openVars );
+                                                        auto param     = function->parameters.begin();
+                                                        auto param_end = function->parameters.end();
+                                                        // For every arguments of its set, check if it matches one of the parameter
+                                                        // The order is important
+                                                        for( auto & arg : argsList ) {
+                                                                // Ignore non-mutex arguments
+                                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                                        // We ran out of parameters but still have arguments
+                                                                        // this function doesn't match
+                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                }
+                                                                // Check if the argument matches the parameter type in the current scope
+                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
+                                                                        // Type doesn't match
+                                                                        stringstream ss;
+                                                                        ss << "candidate function not viable: no known convertion from '";
+                                                                        arg.expr->get_result()->print( ss );
+                                                                        ss << "' to '";
+                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "'\n";
+                                                                        throw SemanticError(ss.str(), function);
+                                                                }
+                                                                param++;
+                                                        }
+                                                        // All arguments match !
+                                                        // Check if parameters are missing
+                                                        if( advance_to_mutex( param, param_end ) ) {
+                                                                // We ran out of arguments but still have parameters left
+                                                                // this function doesn't match
+                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                        }
+                                                        // All parameters match !
+                                                        // Finish the expressions to tie in the proper environments
+                                                        finishExpr( newFunc.expr, resultEnv );
+                                                        for( Alternative & alt : argsList ) {
+                                                                finishExpr( alt.expr, resultEnv );
+                                                        }
+                                                        // This is a match store it and save it for later
+                                                        func_candidates.push_back( newFunc );
+                                                        args_candidates.push_back( argsList );
+                                                }
+                                                catch( SemanticError &e ) {
+                                                        errors.append( e );
+                                                }
+                                        }
+                                }
+                                catch( SemanticError &e ) {
+                                        errors.append( e );
+                                }
+                        }
+                        // Make sure we got the right number of arguments
+                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+                        // Swap the results from the alternative with the unresolved values.
+                        // Alternatives will handle deletion on destruction
+                        std::swap( clause.target.function, func_candidates.front().expr );
+                        for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
+                                std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
+                        }
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( clause.condition, this->indexer );
+                        clause.statement->accept( *visitor );
+                }
+                if( stmt->timeout.statement ) {
+                        // Resolve the timeout as an size_t for now
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
+                        resolveAsIf  ( stmt->timeout.condition, this->indexer );
+                        stmt->timeout.statement->accept( *visitor );
+                }
+                if( stmt->orelse.statement ) {
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( stmt->orelse.condition, this->indexer );
+                        stmt->orelse.statement->accept( *visitor );
+                }
+        }
         template< typename T >
         bool isCharType( T t ) {

src/ResolvExpr/Resolver.h

-                      r201aeb9
+                      rd67cdb7
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
+        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/ResolvExpr/TypeEnvironment.cc

-                      r201aeb9
+                      rd67cdb7
                 for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) {
                         for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) {
 ///       std::cout << "adding " << *theVar;
+///       std::cerr << "adding " << *theVar;
                                 if ( theClass->type ) {
 ///         std::cout << " bound to ";
 ///         theClass->type->print( std::cout );
 ///         std::cout << std::endl;
+///         std::cerr << " bound to ";
+///         theClass->type->print( std::cerr );
+///         std::cerr << std::endl;
                                         sub.add( *theVar, theClass->type );
                                 } else if ( theVar != theClass->vars.begin() ) {
                                         TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
 ///         std::cout << " bound to variable " << *theClass->vars.begin() << std::endl;
+///         std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl;
                                         sub.add( *theVar, newTypeInst );
                                         delete newTypeInst;

src/SymTab/Autogen.cc

-                      r201aeb9
+                      rd67cdb7
 #include "Autogen.h"
-#include <cstddef>                 // for NULL
 #include <algorithm>               // for count_if
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
 …
 #include "AddVisit.h"              // for addVisit
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
+#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
 #include "Common/utility.h"        // for cloneAll, operator+
-#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
+#include "InitTweak/GenInit.h"     // for fixReturnStatements
+#include "ResolvExpr/Resolver.h"   // for resolveDecl
 #include "SymTab/Mangler.h"        // for Mangler
 #include "SynTree/Attribute.h"     // For Attribute
 …
         };
+        class AutogenerateRoutines final : public Visitor {
+            template< typename Visitor >
+            friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+            template< typename Visitor >
+            friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor );
+          public:
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+                typedef Visitor Parent;
+                using Parent::visit;
+        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting {
                 AutogenerateRoutines();
+                virtual void visit( EnumDecl *enumDecl );
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *structDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( TraitDecl *ctxDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+                virtual void visit( FunctionType *ftype );
+                virtual void visit( PointerType *ftype );
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( SwitchStmt *switchStmt );
+                void previsit( EnumDecl * enumDecl );
+                void previsit( StructDecl * structDecl );
+                void previsit( UnionDecl * structDecl );
+                void previsit( TypeDecl * typeDecl );
+                void previsit( TraitDecl * traitDecl );
+                void previsit( FunctionDecl * functionDecl );
+                void previsit( FunctionType * ftype );
+                void previsit( PointerType * ptype );
+                void previsit( CompoundStmt * compoundStmt );
           private:
+                template< typename StmtClass > void visitStatement( StmtClass *stmt );
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                std::set< std::string > structsDone;
+                GenPoly::ScopedSet< std::string > structsDone;
                 unsigned int functionNesting = 0;     // current level of nested functions
                 /// Note: the following maps could be ScopedSets, but it should be easier to work
 …
         /// generates routines for tuple types.
+        /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit
+        /// or anything we currently have that supports adding new declarations for visitors
+        class AutogenTupleRoutines : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+                using Parent::mutate;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+                virtual Type * mutate( TupleType *tupleType );
+                virtual CompoundStmt * mutate( CompoundStmt *compoundStmt );
+        struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef<AutogenTupleRoutines>, public WithGuards, public WithShortCircuiting {
+                void previsit( FunctionDecl *functionDecl );
+                void postvisit( TupleType *tupleType );
+                void previsit( CompoundStmt *compoundStmt );
           private:
 …
         void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
                 AutogenerateRoutines generator;
                 acceptAndAdd( translationUnit, generator );
+                PassVisitor<AutogenerateRoutines> generator;
+                acceptAll( translationUnit, generator );
                 // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
                 // AutogenTupleRoutines tupleGenerator;
                 // tupleGenerator.mutateDeclarationList( translationUnit );
+                // acceptAll( translationUnit, tupleGenerator );
+        }
         bool isUnnamedBitfield( ObjectDecl * obj ) {
                 return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL;
+                return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr;
+        }
 …
                 FunctionDecl * decl = functionDecl->clone();
                 delete decl->get_statements();
                 decl->set_statements( NULL );
+                decl->set_statements( nullptr );
                 declsToAdd.push_back( decl );
                 decl->fixUniqueId();
 …
                                 assert( ! func->get_functionType()->get_parameters().empty() );
                                 ObjectDecl * dstParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().front() );
                                 ObjectDecl * srcParam = NULL;
+                                ObjectDecl * srcParam = nullptr;
                                 if ( func->get_functionType()->get_parameters().size() == 2 ) {
                                         srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
 …
                                 assert( dstParam );
                                 Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
+                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
                                 makeStructMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
 …
                                 } else {
                                         // no matching parameter, initialize field with default ctor
                                         makeStructMemberOp( dstParam, NULL, field, func );
+                                        makeStructMemberOp( dstParam, nullptr, field, func );
+                                }
+                        }
 …
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
+                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
+                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
+                if ( LinkageSpec::isBuiltin( aggregateDecl->get_linkage() ) ) {
                         return;
+                }
                 // Make function polymorphic in same parameters as generic struct, if applicable
                 const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                const std::list< TypeDecl * > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
                 // generate each of the functions based on the supplied FuncData objects
 …
                 // the order here determines the order that these functions are generated.
                 // assignment should come last since it uses copy constructor in return.
+                data.push_back( FuncData( "?{}", genDefaultType, constructable ) );
+                data.push_back( FuncData( "?{}", genCopyType, copyable ) );
+                data.push_back( FuncData( "^?{}", genDefaultType, destructable ) );
+                data.push_back( FuncData( "?=?", genAssignType, assignable ) );
+        }
+        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
+                data.emplace_back( "?{}", genDefaultType, constructable );
+                data.emplace_back( "?{}", genCopyType, copyable );
+                data.emplace_back( "^?{}", genDefaultType, destructable );
+                data.emplace_back( "?=?", genAssignType, assignable );
+        }
+        void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) {
+                visit_children = false;
                 if ( ! enumDecl->get_members().empty() ) {
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
 …
+        }
+        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
+                if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
+                        for ( TypeDecl * typeDecl : structDecl->get_parameters() ) {
+        void AutogenerateRoutines::previsit( StructDecl * structDecl ) {
+                visit_children = false;
+                if ( structDecl->has_body() && structsDone.find( structDecl->name ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->name );
+                        for ( TypeDecl * typeDecl : structDecl->parameters ) {
                                 // need to visit assertions so that they are added to the appropriate maps
                                 acceptAll( typeDecl->get_assertions(), *this );
                                 structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
+                                acceptAll( typeDecl->assertions, *visitor );
+                                structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) );
+                        }
                         structInst.set_baseStruct( structDecl );
                         makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data );
                         structsDone.insert( structDecl->get_name() );
+                        structsDone.insert( structDecl->name );
                 } // if
+        }
+        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
+        void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
+                visit_children = false;
                 if ( ! unionDecl->get_members().empty() ) {
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
 …
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
+        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
+        void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
+                visit_children = false;
                 if ( ! typeDecl->base ) return;
 …
+        }
+        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+                for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
+                        statements.insert( i, new DeclStmt( noLabels, *decl ) );
+                } // for
+                declsToAdd.clear();
+        }
+        void AutogenerateRoutines::visit( FunctionType *) {
+        void AutogenerateRoutines::previsit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
+        }
+        void AutogenerateRoutines::visit( PointerType *) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
+        }
+        void AutogenerateRoutines::visit( TraitDecl *) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( TraitDecl * ) {
                 // ensure that we don't add assignment ops for types defined as part of the trait
+        }
+        template< typename StmtClass >
+        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
+                std::set< std::string > oldStructs = structsDone;
+                addVisit( stmt, *this );
+                structsDone = oldStructs;
+        }
+        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
+                visit_children = false;
                 // record the existence of this function as appropriate
                 insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
 …
                 insert( functionDecl, destructable, InitTweak::isDestructor );
                 maybeAccept( functionDecl->get_functionType(), *this );
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
                 maybeAccept( functionDecl->get_statements(), *this );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
+        }
+        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
+                constructable.beginScope();
+                assignable.beginScope();
+                copyable.beginScope();
+                destructable.beginScope();
+                visitStatement( compoundStmt );
+                constructable.endScope();
+                assignable.endScope();
+                copyable.endScope();
+                destructable.endScope();
+        }
+        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
+                visitStatement( switchStmt );
+        void AutogenerateRoutines::previsit( CompoundStmt * ) {
+                GuardScope( constructable );
+                GuardScope( assignable );
+                GuardScope( copyable );
+                GuardScope( destructable );
+                GuardScope( structsDone );
+        }
 …
+        }
+        Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
+                tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
+        void AutogenTupleRoutines::postvisit( TupleType * tupleType ) {
                 std::string mangleName = SymTab::Mangler::mangleType( tupleType );
                 if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
+                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return;
                 seenTuples.insert( mangleName );
 …
                 makeTupleFunctionBody( dtorDecl );
+                addDeclaration( ctorDecl );
+                addDeclaration( copyCtorDecl );
+                addDeclaration( dtorDecl );
+                addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return
+                return tupleType;
+        }
+        DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+                declsToAddBefore.push_back( ctorDecl );
+                declsToAddBefore.push_back( copyCtorDecl );
+                declsToAddBefore.push_back( dtorDecl );
+                declsToAddBefore.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+        }
+        void AutogenTupleRoutines::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
+                return functionDecl;
+        }
+        CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
+                seenTuples.beginScope();
+                compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
+                seenTuples.endScope();
+                return compoundStmt;
+        }
+        void AutogenTupleRoutines::previsit( CompoundStmt * ) {
+                GuardScope( seenTuples );
+        }
 } // SymTab

src/SymTab/FixFunction.cc

-                      r201aeb9
+                      rd67cdb7
         DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
+                // can't delete function type because it may contain assertions, so transfer ownership to new object
                 ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
                 functionDecl->get_attributes().clear();
+                // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
+                functionDecl->set_type( functionDecl->get_type()->clone() );
+                functionDecl->type = nullptr;
                 delete functionDecl;
                 return pointer;

src/SymTab/Indexer.cc

-                      r201aeb9
+                      rd67cdb7
 namespace SymTab {
-        struct NewScope {
-                NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); }
-                ~NewScope() { indexer.leaveScope(); }
-                SymTab::Indexer & indexer;
-        };
-        template< typename TreeType, typename VisitorType >
-        inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
-                visitor.enterScope();
-                maybeAccept( tree, visitor );
-                visitor.leaveScope();
+        }
         typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
         typedef std::unordered_map< std::string, MangleTable > IdTable;
 …
+        }
         Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
         Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
         Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
+        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
+        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
+        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
                 that.tables = 0;
+        }

src/SymTab/Indexer.h

-                      r201aeb9
+                      rd67cdb7
         class Indexer {
           public:
                 explicit Indexer( bool useDebug = false );
+                explicit Indexer();
                 Indexer( const Indexer &that );
 …
                 void addTrait( TraitDecl *decl );
+                bool doDebug = false; ///< Display debugging trace?
           private:
                 struct Impl;
 …
                 Impl *tables;         ///< Copy-on-write instance of table data structure
                 unsigned long scope;  ///< Scope index of this pointer
-                bool doDebug;         ///< Display debugging trace?
                 /// Takes a new ref to a table (returns null if null)

src/SymTab/Mangler.cc

-                      r201aeb9
+                      rd67cdb7
 namespace SymTab {
         std::string Mangler::mangleType( Type *ty ) {
+        std::string Mangler::mangleType( Type * ty ) {
                 Mangler mangler( false, true );
                 maybeAccept( ty, mangler );
 …
+        }
         void Mangler::mangleDecl( DeclarationWithType *declaration ) {
+        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
                 bool wasTopLevel = isTopLevel;
                 if ( isTopLevel ) {
 …
+        }
         void Mangler::visit( ObjectDecl *declaration ) {
+        void Mangler::visit( ObjectDecl * declaration ) {
                 mangleDecl( declaration );
+        }
         void Mangler::visit( FunctionDecl *declaration ) {
+        void Mangler::visit( FunctionDecl * declaration ) {
                 mangleDecl( declaration );
+        }
         void Mangler::visit( VoidType *voidType ) {
+        void Mangler::visit( VoidType * voidType ) {
                 printQualifiers( voidType );
                 mangleName << "v";
+        }
         void Mangler::visit( BasicType *basicType ) {
+        void Mangler::visit( BasicType * basicType ) {
                 static const char *btLetter[] = {
                         "b",    // Bool
 …
+        }
         void Mangler::visit( PointerType *pointerType ) {
+        void Mangler::visit( PointerType * pointerType ) {
                 printQualifiers( pointerType );
                 mangleName << "P";
 …
+        }
         void Mangler::visit( ArrayType *arrayType ) {
+        void Mangler::visit( ArrayType * arrayType ) {
                 // TODO: encode dimension
                 printQualifiers( arrayType );
 …
+        }
         void Mangler::visit( ReferenceType *refType ) {
+        void Mangler::visit( ReferenceType * refType ) {
                 printQualifiers( refType );
                 mangleName << "R";
 …
+        }
         void Mangler::visit( FunctionType *functionType ) {
+        void Mangler::visit( FunctionType * functionType ) {
                 printQualifiers( functionType );
                 mangleName << "F";
 …
+        }
         void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
+        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
                 printQualifiers( refType );
 …
+        }
         void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
+        void Mangler::mangleGenericRef( ReferenceToType * refType, std::string prefix ) {
                 printQualifiers( refType );
 …
+        }
         void Mangler::visit( StructInstType *aggregateUseType ) {
+        void Mangler::visit( StructInstType * aggregateUseType ) {
                 if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
                 else mangleRef( aggregateUseType, "s" );
+        }
         void Mangler::visit( UnionInstType *aggregateUseType ) {
+        void Mangler::visit( UnionInstType * aggregateUseType ) {
                 if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
                 else mangleRef( aggregateUseType, "u" );
+        }
         void Mangler::visit( EnumInstType *aggregateUseType ) {
+        void Mangler::visit( EnumInstType * aggregateUseType ) {
                 mangleRef( aggregateUseType, "e" );
+        }
         void Mangler::visit( TypeInstType *typeInst ) {
+        void Mangler::visit( TypeInstType * typeInst ) {
                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                 if ( varNum == varNums.end() ) {
 …
+        }
         void Mangler::visit( TupleType *tupleType ) {
+        void Mangler::visit( TupleType * tupleType ) {
                 printQualifiers( tupleType );
                 mangleName << "T";
                 acceptAll( tupleType->get_types(), *this );
+                acceptAll( tupleType->types, *this );
                 mangleName << "_";
+        }
         void Mangler::visit( VarArgsType *varArgsType ) {
+        void Mangler::visit( VarArgsType * varArgsType ) {
                 printQualifiers( varArgsType );
                 mangleName << "VARGS";
+        }
         void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
+        void Mangler::visit( ZeroType * ) {
                 mangleName << "Z";
+        }
         void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
+        void Mangler::visit( OneType * ) {
                 mangleName << "O";
+        }
         void Mangler::visit( TypeDecl *decl ) {
+        void Mangler::visit( TypeDecl * decl ) {
                 static const char *typePrefix[] = { "BT", "BD", "BF" };
                 mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
+        }
 …
+        }
         void Mangler::printQualifiers( Type *type ) {
+        void Mangler::printQualifiers( Type * type ) {
                 // skip if not including qualifiers
                 if ( typeMode ) return;
 …
                         int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
                         mangleName << "A";
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                 switch ( (*i)->get_kind() ) {
                                   case TypeDecl::Any:
 …
                                         assert( false );
                                 } // switch
                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
+                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
+                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
                                         Mangler sub_mangler( mangleOverridable, typeMode );
                                         sub_mangler.nextVarNum = nextVarNum;
 …
                         mangleName << "V";
                 } // if
+                if ( type->get_mutex() ) {
+                        mangleName << "M";
+                } // if
                 // Removed due to restrict not affecting function compatibility in GCC
 //              if ( type->get_isRestrict() ) {
 …
 //              } // if
                 if ( type->get_lvalue() ) {
+                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
                         mangleName << "L";
                 } // if
+                }
                 if ( type->get_atomic() ) {
                         mangleName << "A";

src/SymTab/Validate.cc

-                      r201aeb9
+                      rd67cdb7
 #include "FixFunction.h"               // for FixFunction
 #include "Indexer.h"                   // for Indexer
+#include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
 #include "Parser/LinkageSpec.h"        // for C
 …
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
         struct ForallPointerDecay final {
                 void previsit( ObjectDecl *object );
                 void previsit( FunctionDecl *func );
+                void previsit( ObjectDecl * object );
+                void previsit( FunctionDecl * func );
         };
 …
         /// Fix up assertions - flattens assertion lists, removing all trait instances
         void forallFixer( Type * func ) {
                 for ( TypeDecl * type : func->get_forall() ) {
+        void forallFixer( std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
+                for ( TypeDecl * type : forall ) {
                         std::list< DeclarationWithType * > asserts;
                         asserts.splice( asserts.end(), type->assertions );
 …
                                 assertion = assertion->acceptMutator( fixer );
                                 if ( fixer.get_isVoid() ) {
                                         throw SemanticError( "invalid type void in assertion of function ", func );
+                                        throw SemanticError( "invalid type void in assertion of function ", node );
                                 } // if
                         } // for
 …
         void ForallPointerDecay::previsit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
                         forallFixer( pointer->get_base() );
+                forallFixer( object->type->forall, object );
+                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) {
+                        forallFixer( pointer->base->forall, object );
                 } // if
                 object->fixUniqueId();
 …
         void ForallPointerDecay::previsit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
+                forallFixer( func->type->forall, func );
                 func->fixUniqueId();
+        }

src/SynTree/BaseSyntaxNode.h

-                      r201aeb9
+                      rd67cdb7
         virtual void accept( Visitor & v ) = 0;
   virtual void print( std::ostream & os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const = 0;
 };
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node );
 // Local Variables: //

src/SynTree/CompoundStmt.cc

-                      r201aeb9
+                      rd67cdb7
 CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
+}
+CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
+}

src/SynTree/Constant.cc

-                      r201aeb9
+                      rd67cdb7
 Constant Constant::from_bool( bool b ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::Bool ), b ? "1" : "0" , (unsigned long long int)b );
+}
+Constant Constant::from_char( char c ) {
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::Char ), std::to_string( c ), (unsigned long long int)c );
+}

src/SynTree/Constant.h

r201aeb9	rd67cdb7
40	40	/// generates a boolean constant of the given bool
41	41	static Constant from_bool( bool b );
	42	/// generates a char constant of the given char
	43	static Constant from_char( char c );
42	44	/// generates an integer constant of the given int
43	45	static Constant from_int( int i );

src/SynTree/Declaration.cc

-                      r201aeb9
+                      rd67cdb7
+}
-std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
-        if ( decl ){
-                decl->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {

src/SynTree/Declaration.h

-                      r201aeb9
+                      rd67cdb7
         void fixUniqueId( void );
         virtual Declaration *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
+        virtual void accept( Visitor &v ) override = 0;
         virtual Declaration *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
         virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
 …
         //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
         virtual DeclarationWithType *clone() const = 0;
         virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+        virtual DeclarationWithType *clone() const override = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
         virtual Type * get_type() const = 0;
 …
         virtual ~ObjectDecl();
         virtual Type * get_type() const { return type; }
         virtual void set_type(Type *newType) { type = newType; }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type *newType) override { type = newType; }
         Initializer *get_init() const { return init; }
 …
         static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
         virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 …
         virtual ~FunctionDecl();
         Type * get_type() const { return type; }
         virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
         FunctionType * get_functionType() const { return type; }
 …
         void set_statements( CompoundStmt *newValue ) { statements = newValue; }
         virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 …
         virtual std::string typeString() const = 0;
         virtual NamedTypeDecl *clone() const = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual NamedTypeDecl *clone() const override = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 …
         TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
         virtual std::string genTypeString() const;
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
 …
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
         virtual std::string typeString() const;
         virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual std::string typeString() const override;
+        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
 };
 …
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
   protected:
         virtual std::string typeString() const = 0;
 …
         bool is_thread() { return kind == DeclarationNode::Thread; }
         virtual StructDecl *clone() const { return new StructDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
         DeclarationNode::Aggregate kind;
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         UnionDecl( const UnionDecl &other ) : Parent( other ) {}
         virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}
         virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         TraitDecl( const TraitDecl &other ) : Parent( other ) {}
         virtual TraitDecl *clone() const { return new TraitDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
+        virtual AsmDecl *clone() const { return new AsmDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Declaration * decl );
+        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+};
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );

src/SynTree/Expression.cc

-                      r201aeb9
+                      rd67cdb7
+}
-std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
-        if ( expr ) {
-                expr->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Expression.h

-                      r201aeb9
+                      rd67cdb7
 };
-std::ostream & operator<<( std::ostream & out, const Expression * expr );
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.cc

-                      r201aeb9
+                      rd67cdb7
+}
-std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
-        if ( init ) {
-                init->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
-std::ostream & operator<<( std::ostream & out, const Designation * des ) {
-        if ( des ) {
-                des->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.h

r201aeb9	rd67cdb7
38	38
39	39	virtual Designation * clone() const { return new Designation( *this ); };
40		virtual void accept( Visitor &v ) { v.visit( this ); }

Context Navigation

Legend: