Index: doc/proposals/concurrency/text/concurrency.tex
===================================================================
--- doc/proposals/concurrency/text/concurrency.tex	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ doc/proposals/concurrency/text/concurrency.tex	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -4,9 +4,9 @@
 % ======================================================================
 % ======================================================================
-Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account. 
-
-Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and shared objects. At the lowest level, concurrent paradigms are implemented as atomic operations and locks. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}. 
-
-An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for general purpose language, which is why it was rejected as the core paradigm for concurrency in \CFA. 
+Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account.
+
+Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and shared objects. At the lowest level, concurrent paradigms are implemented as atomic operations and locks. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}.
+
+An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for general purpose language, which is why it was rejected as the core paradigm for concurrency in \CFA.
 
 One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency-construct.
@@ -101,5 +101,5 @@
 	}
 \end{cfacode}
-The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order. 
+The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order.
 
 However, such use leads the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires:
@@ -169,5 +169,5 @@
 \end{tabular}
 \end{center}
-Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting. 
+Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting.
 
 % ======================================================================
@@ -178,7 +178,7 @@
 Depending on the choice of semantics for when monitor locks are acquired, interaction between monitors and \CFA's concept of polymorphism can be complex to support. However, it is shown that entry-point locking solves most of the issues.
 
-First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. 
-
-Before looking into complex control flow, it is important to present the difference between the two acquiring options : \gls{callsite-locking} and \gls{entry-point-locking}, i.e. acquiring the monitors before making a mutex routine call or as the first instruction of the mutex routine call. For example:
+First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines.
+
+Before looking into complex control-flow, it is important to present the difference between the two acquiring options : callsite and entry-point locking, i.e. acquiring the monitors before making a mutex routine call or as the first operation of the mutex routine-call. For example:
 \begin{center}
 \setlength\tabcolsep{1.5pt}
@@ -245,16 +245,18 @@
 \end{center}
 
-\Gls{callsite-locking} is inefficient, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else. Note that the \code{mutex} keyword relies on the resolver rather than another form of language, which mean that in cases where a generic monitor routine is actually desired, writing a mutex routine is possible with the proper trait. This is possible because monitors are designed in terms a trait. For example:
+\Gls{callsite-locking} is inefficient, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else.
+
+Note the \code{mutex} keyword relies on the resolver, which means that in cases where a generic monitor routine is actually desired, writing a mutex routine is possible with the proper trait. This is possible because monitors are designed in terms a trait. For example:
 \begin{cfacode}
 //Incorrect
 //T is not a monitor
 forall(dtype T)
-void foo(T * mutex t); 
+void foo(T * mutex t);
 
 //Correct
-//this function only works on monitors 
+//this function only works on monitors
 //(any monitor)
 forall(dtype T | is_monitor(T))
-void bar(T * mutex t)); 
+void bar(T * mutex t));
 \end{cfacode}
 
@@ -267,5 +269,5 @@
 In addition to mutual exclusion, the monitors at the core of \CFA's concurrency can also be used to achieve synchronisation. With monitors, this is generally achieved with internal or external scheduling as in\cit. Since internal scheduling of single monitors is mostly a solved problem, this proposal concentraits on extending internal scheduling to multiple monitors at once. Indeed, like the \gls{group-acquire} semantics, internal scheduling extends to multiple monitors at once in a way that is natural to the user but requires additional complexity on the implementation side.
 
-First, Here is a simple example of such a technique:
+First, here is a simple example of such a technique:
 
 \begin{cfacode}
@@ -289,5 +291,5 @@
 \end{cfacode}
 
-There are two details to note here. First, there \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This is needed to respect mutual-exclusion. Second, in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. 
+There are two details to note here. First, there \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This is needed to respect mutual-exclusion. Second, in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering.
 
 An important aspect to take into account here is that \CFA does not allow barging, which means that once function \code{bar} releases the monitor, foo is guaranteed to resume immediately after (unless some other thread waited on the same condition). This guarantees offers the benefit of not having to loop arount waits in order to guarantee that a condition is still met. The main reason \CFA offers this guarantee is that users can easily introduce barging if it becomes a necessity but adding barging prevention or barging avoidance is more involved without language support. Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design of \CFA concurrency.
@@ -317,6 +319,5 @@
 \end{pseudo}
 \end{multicols}
-
-The previous example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. There is an important thing to note here, both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This restriction is hidden on the user side in \uC, as it is a logical requirement for barging prevention. 
+The example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. There is an important thing to note here, both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This restriction is hidden on the user side in \uC, as it is a logical requirement for barging prevention.
 
 A direct extension of the previous example is the \gls{group-acquire} version:
@@ -337,5 +338,4 @@
 \end{pseudo}
 \end{multicols}
-
 This version uses \gls{group-acquire} (denoted using the \& symbol), but the presence of multiple monitors does not add a particularly new meaning. Synchronization happens between the two threads in exactly the same way and order. The only difference is that mutual exclusion covers more monitors. On the implementation side, handling multiple monitors does add a degree of complexity as the next few examples demonstrate.
 
@@ -397,8 +397,8 @@
 \end{center}
 
-It is particularly important to pay attention to code sections 8 and 3, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 17), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. We are therefore left with three options:
+It is particularly important to pay attention to code sections 8 and 3, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 16), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. There are three options:
 
 \subsubsection{Delaying signals}
-The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed is what fits most closely to the behaviour of single monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single groupd of object. Effectively making the existing single monitor semantic viable by simply changing monitors to monitor collections.
+The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed because this semantics fits most closely to the behaviour of single monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single group of object, effectively making the existing single monitor semantic viable by simply changing monitors to monitor collections.
 \begin{multicols}{2}
 Waiter
@@ -424,5 +424,5 @@
 \end{pseudo}
 \end{multicols}
-However, this solution can become much more complicated depending on what is executed while secretly holding B. Indeed, nothing prevents a user from signalling monitor A on a different condition variable:
+However, this solution can become much more complicated depending on what is executed while secretly holding B (at line 10). Indeed, nothing prevents a user from signalling monitor A on a different condition variable:
 \newpage
 \begin{multicols}{2}
@@ -459,14 +459,16 @@
 \end{multicols}
 
-The goal in this solution is to avoid the need to transfer ownership of a subset of the condition monitors. However, this goal is unreacheable in the previous example. Depending on the order of signals (line 12 and 15) two cases can happen. Note that ordering is not determined by a race condition but by whether signalled threads are enqueued in FIFO or FILO order. However, regardless of the answer, users can move line 15 before line 11 and get the reverse effect.
-
-\paragraph{Case 1: thread 1 will go first.} In this case, the problem is that monitor A needs to be passed to thread 2 when thread 1 is done with it. 
-\paragraph{Case 2: thread 2 will go first.} In this case, the problem is that monitor B needs to be passed to thread 1. This can be done directly or using thread 2 as an intermediate. 
+The goal in this solution is to avoid the need to transfer ownership of a subset of the condition monitors. However, this goal is unreacheable in the previous example. Depending on the order of signals (line 12 and 15) two cases can happen.
+
+\paragraph{Case 1: thread 1 goes first.} In this case, the problem is that monitor A needs to be passed to thread 2 when thread 1 is done with it.
+\paragraph{Case 2: thread 2 goes first.} In this case, the problem is that monitor B needs to be passed to thread 1, which can be done directly or using thread 2 as an intermediate.
 \\
 
+Note that ordering is not determined by a race condition but by whether signalled threads are enqueued in FIFO or FILO order. However, regardless of the answer, users can move line 15 before line 11 and get the reverse effect.
+
 In both cases however, the threads need to be able to distinguish on a per monitor basis which ones need to be released and which ones need to be transferred. Which means monitors cannot be handled as a single homogenous group.
 
 \subsubsection{Dependency graphs}
-In the Listing 1 pseudo-code, there is a solution which would statisfy both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it then the problem is solved. Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example the following code which is just a direct extension to three monitors requires at least three ownership transfer and has multiple solutions: 
+In the Listing 1 pseudo-code, there is a solution which statisfies both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it then the problem is solved. Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example, the following code, which is just a direct extension to three monitors, requires at least three ownership transfer and has multiple solutions:
 
 \begin{multicols}{2}
@@ -496,5 +498,5 @@
 
 \subsubsection{Partial signalling}
-Finally, the solution that was chosen for \CFA is to use partial signalling. Consider the following case:
+Finally, the solution that is chosen for \CFA is to use partial signalling. Consider the following case:
 
 \begin{multicols}{2}
@@ -518,6 +520,5 @@
 \end{pseudo}
 \end{multicols}
-
-The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated in to only two actions, passing monitors to the next owner when they should be release and conditionnaly waking threads if all conditions are met. Contrary to the other solutions, this solution quickly hits an upper bound on complexity of implementation.
+The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated into only two actions, passing monitors to the next owner when they should be release and conditionnaly waking threads if all conditions are met. Contrary to the other solutions, this solution quickly hits an upper bound on complexity of implementation.
 
 % ======================================================================
@@ -526,5 +527,5 @@
 % ======================================================================
 % ======================================================================
-An important note is that, until now, signalling a monitor was a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement. However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation. This is achieved using the \code{signal_block} routine\footnote{name to be discussed}.
+An important note is that, until now, signalling a monitor was a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement. However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation, which is achieved using the \code{signal_block} routine\footnote{name to be discussed}.
 
 For example here is an example highlighting the difference in behaviour:
@@ -625,11 +626,11 @@
 	bool inUse;
 public:
-	void P() { 
-		if(inUse) wait(c); 
+	void P() {
+		if(inUse) wait(c);
 		inUse = true;
 	}
-	void V() { 
-		inUse = false;		
-		signal(c); 
+	void V() {
+		inUse = false;
+		signal(c);
 	}
 }
@@ -639,9 +640,9 @@
 	bool inUse;
 public:
-	void P() { 
-		if(inUse) _Accept(V); 
+	void P() {
+		if(inUse) _Accept(V);
 		inUse = true;
 	}
-	void g() { 
+	void g() {
 		inUse = false;
 
Index: doc/proposals/concurrency/version
===================================================================
--- doc/proposals/concurrency/version	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ doc/proposals/concurrency/version	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -1,1 +1,1 @@
-0.9.119
+0.9.122
Index: src/CodeGen/CodeGenerator.cc
===================================================================
--- src/CodeGen/CodeGenerator.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/CodeGen/CodeGenerator.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -13,9 +13,9 @@
 // Update Count     : 485
 //
+#include "CodeGenerator.h"
 
 #include <cassert>                   // for assert, assertf
 #include <list>                      // for _List_iterator, list, list<>::it...
 
-#include "CodeGenerator.h"
 #include "Common/SemanticError.h"    // for SemanticError
 #include "Common/UniqueName.h"       // for UniqueName
Index: src/CodeGen/GenType.cc
===================================================================
--- src/CodeGen/GenType.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/CodeGen/GenType.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -13,4 +13,5 @@
 // Update Count     : 22
 //
+#include "GenType.h"
 
 #include <cassert>                // for assert, assertf
@@ -19,5 +20,4 @@
 
 #include "CodeGenerator.h"        // for CodeGenerator
-#include "GenType.h"
 #include "SynTree/Declaration.h"  // for DeclarationWithType
 #include "SynTree/Expression.h"   // for Expression
Index: src/CodeGen/Generate.cc
===================================================================
--- src/CodeGen/Generate.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/CodeGen/Generate.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -13,4 +13,5 @@
 // Update Count     : 6
 //
+#include "Generate.h"
 
 #include <iostream>                  // for ostream, endl, operator<<
@@ -20,5 +21,4 @@
 #include "CodeGenerator.h"           // for CodeGenerator, doSemicolon, oper...
 #include "GenType.h"                 // for genPrettyType
-#include "Generate.h"
 #include "Parser/LinkageSpec.h"      // for isBuiltin, isGeneratable
 #include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
Index: src/CodeTools/TrackLoc.cc
===================================================================
--- src/CodeTools/TrackLoc.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/CodeTools/TrackLoc.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -16,18 +16,13 @@
 #include "TrackLoc.h"
 
-#include <cstdlib>                    // for size_t, exit, EXIT_FAILURE
-#include <iostream>                   // for operator<<, ostream, basic_ostream
-#include <iterator>                   // for back_inserter, inserter
-#include <stack>                      // for stack
-#include <string>                     // for operator<<, string
-#include <typeindex>                  // for type_index
+#include <cstdlib>                   // for exit, EXIT_FAILURE
+#include <iostream>                  // for operator<<, ostream, basic_ostream
+#include <stack>                     // for stack
+#include <string>                    // for operator<<, string
+#include <typeindex>                 // for type_index
 
-#include "Common/PassVisitor.h"       // for PassVisitor
-#include "Common/PassVisitor.impl.h"  // for acceptAll
-#include "Common/SemanticError.h"     // for SemanticError
-#include "Common/utility.h"           // for CodeLocation
-#include "SynTree/BaseSyntaxNode.h"   // for BaseSyntaxNode
-#include "SynTree/Mutator.h"          // for mutateAll
-#include "SynTree/Visitor.h"          // for acceptAll
+#include "Common/PassVisitor.h"      // for PassVisitor
+#include "Common/utility.h"          // for CodeLocation
+#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
 
 class Declaration;
@@ -46,5 +41,5 @@
 		std::stack< CodeLocation * > parents;
 	public:
-		LocationPrinter(size_t printLevel) : 
+		LocationPrinter(size_t printLevel) :
 			printLevel(printLevel), lastNode(nullptr)
 		{}
@@ -65,8 +60,8 @@
 				if ( !parents.empty() ) {
 					node->location = *parents.top();
-				} 
+				}
 				else if (nullptr != lastNode) {
 					node->location = *lastNode;
-				} 
+				}
 				else {
 					std::cerr << "Top level node has no CodeLocation " << name << std::endl;
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/Common/PassVisitor.impl.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -1,3 +1,4 @@
 #pragma once
+// IWYU pragma: private, include "PassVisitor.h"
 
 #define VISIT_START( node )                     \
Index: src/Common/PassVisitor.proto.h
===================================================================
--- src/Common/PassVisitor.proto.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/Common/PassVisitor.proto.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -1,3 +1,4 @@
 #pragma once
+// IWYU pragma: private, include "PassVisitor.h"
 
 template<typename pass_type>
Index: src/SymTab/AddVisit.h
===================================================================
--- src/SymTab/AddVisit.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/AddVisit.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -14,4 +14,6 @@
 //
 
+#include "SynTree/Statement.h"
+
 namespace SymTab {
 	void addDecls( std::list< Declaration* > &declsToAdd, std::list< Statement* > &statements, std::list< Statement* >::iterator i );
@@ -28,5 +30,5 @@
 
 			if ( stmt == stmts.end() ) break;
-			
+
 			// run mutator on statement
 			maybeAccept( *stmt, visitor );
@@ -59,5 +61,5 @@
 
 			if ( decl == translationUnit.end() ) break;
-			
+
 			// run mutator on declaration
 			maybeAccept( *decl, visitor );
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Autogen.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -13,19 +13,25 @@
 // Update Count     : 62
 //
-
-#include <list>
-#include <iterator>
-#include "SynTree/Visitor.h"
-#include "SynTree/Type.h"
-#include "SynTree/Statement.h"
-#include "SynTree/TypeSubstitution.h"
-#include "Common/utility.h"
-#include "AddVisit.h"
-#include "MakeLibCfa.h"
 #include "Autogen.h"
-#include "GenPoly/ScopedSet.h"
-#include "Common/ScopedMap.h"
-#include "SymTab/Mangler.h"
-#include "GenPoly/DeclMutator.h"
+
+#include <algorithm>               // for count_if
+#include <cassert>                 // for safe_dynamic_cast, assert, assertf
+#include <iterator>                // for back_insert_iterator, back_inserter
+#include <list>                    // for list, _List_iterator, list<>::iter...
+#include <set>                     // for set, _Rb_tree_const_iterator
+#include <vector>                  // for vector
+
+#include "AddVisit.h"              // for addVisit
+#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 "SymTab/Mangler.h"        // for Mangler
+#include "SynTree/Mutator.h"       // for maybeMutate
+#include "SynTree/Statement.h"     // for CompoundStmt, ReturnStmt, ExprStmt
+#include "SynTree/Type.h"          // for FunctionType, Type, TypeInstType
+#include "SynTree/Visitor.h"       // for maybeAccept, Visitor, acceptAll
+
+class Attribute;
 
 namespace SymTab {
@@ -512,5 +518,5 @@
 		// Make function polymorphic in same parameters as generic union, if applicable
 		const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
-		
+
 		// default ctor/dtor need only first parameter
 		// void ?{}(T *); void ^?{}(T *);
Index: src/SymTab/Autogen.h
===================================================================
--- src/SymTab/Autogen.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Autogen.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -16,10 +16,19 @@
 #pragma once
 
-#include <string>
-#include "SynTree/Statement.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Initializer.h"
-#include "InitTweak/InitTweak.h"
+#include <cassert>                // for assert
+#include <iterator>               // for back_insert_iterator, back_inserter
+#include <list>                   // for list
+#include <string>                 // for string, operator==
+
+#include "Common/UniqueName.h"    // for UniqueName
+#include "InitTweak/InitTweak.h"  // for InitExpander
+#include "Parser/LinkageSpec.h"   // for C
+#include "SynTree/Constant.h"     // for Constant
+#include "SynTree/Declaration.h"  // for ObjectDecl, Declaration (ptr only)
+#include "SynTree/Expression.h"   // for UntypedExpr, NameExpr, VariableExpr
+#include "SynTree/Initializer.h"  // for SingleInit
+#include "SynTree/Label.h"        // for Label, noLabels
+#include "SynTree/Statement.h"    // for Statement (ptr only), CompoundStmt
+#include "SynTree/Type.h"         // for Type, ArrayType, Type::Qualifiers
 
 namespace SymTab {
@@ -154,5 +163,5 @@
 		if ( isUnnamedBitfield( obj ) ) return;
 
-		bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
+		bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
 		std::list< Statement * > stmts;
 		genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
Index: src/SymTab/FixFunction.cc
===================================================================
--- src/SymTab/FixFunction.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/FixFunction.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -15,8 +15,10 @@
 
 #include "FixFunction.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "Common/utility.h"
+
+#include <list>                   // for list
+
+#include "Common/utility.h"       // for maybeClone
+#include "SynTree/Declaration.h"  // for FunctionDecl, ObjectDecl, Declarati...
+#include "SynTree/Type.h"         // for ArrayType, PointerType, Type, Basic...
 
 namespace SymTab {
Index: src/SymTab/FixFunction.h
===================================================================
--- src/SymTab/FixFunction.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/FixFunction.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixFunction.h -- 
+// FixFunction.h --
 //
 // Author           : Richard C. Bilson
@@ -16,5 +16,6 @@
 #pragma once
 
-#include "SynTree/Mutator.h"
+#include "SynTree/Mutator.h"  // for Mutator
+#include "SynTree/SynTree.h"  // for Types
 
 namespace SymTab {
@@ -43,5 +44,5 @@
 		virtual Type* mutate(ZeroType *zeroType);
 		virtual Type* mutate(OneType *oneType);
-  
+
 		bool isVoid;
 	};
Index: src/SymTab/ImplementationType.cc
===================================================================
--- src/SymTab/ImplementationType.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/ImplementationType.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -15,9 +15,11 @@
 
 #include "ImplementationType.h"
-#include "SynTree/Type.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Visitor.h"
-#include "SymTab/Indexer.h"
-#include "Common/utility.h"
+
+#include <list>                   // for list, _List_iterator, list<>::iterator
+
+#include "SymTab/Indexer.h"       // for Indexer
+#include "SynTree/Declaration.h"  // for NamedTypeDecl
+#include "SynTree/Type.h"         // for TupleType, Type, ArrayType, Pointer...
+#include "SynTree/Visitor.h"      // for Visitor
 
 
Index: src/SymTab/ImplementationType.h
===================================================================
--- src/SymTab/ImplementationType.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/ImplementationType.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -16,8 +16,9 @@
 #pragma once
 
-#include "SynTree/SynTree.h"
-#include "SymTab/Indexer.h"
+class Type;
 
 namespace SymTab {
+class Indexer;
+
 	Type *implementationType( Type *, const SymTab::Indexer &indexer );
 
Index: src/SymTab/Indexer.cc
===================================================================
--- src/SymTab/Indexer.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Indexer.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -16,24 +16,23 @@
 #include "Indexer.h"
 
-#include <string>
-#include <typeinfo>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <algorithm>
-
-#include "Mangler.h"
-
-#include "Common/utility.h"
-
-#include "ResolvExpr/typeops.h"
-
-#include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "SynTree/Statement.h"
-
-#include "InitTweak/InitTweak.h"
+#include <cassert>                 // for assert, safe_dynamic_cast
+#include <iostream>                // for operator<<, basic_ostream, ostream
+#include <string>                  // for string, operator<<, operator!=
+#include <unordered_map>           // for operator!=, unordered_map<>::const...
+#include <unordered_set>           // for unordered_set
+#include <utility>                 // for pair, make_pair, move
+
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for cloneAll
+#include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
+#include "Mangler.h"               // for Mangler
+#include "Parser/LinkageSpec.h"    // for isMangled, isOverridable, Spec
+#include "ResolvExpr/typeops.h"    // for typesCompatible
+#include "SynTree/Constant.h"      // for Constant
+#include "SynTree/Declaration.h"   // for DeclarationWithType, FunctionDecl
+#include "SynTree/Expression.h"    // for Expression, ImplicitCopyCtorExpr
+#include "SynTree/Initializer.h"   // for Initializer
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement, ForStmt (...
+#include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
 
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
Index: src/SymTab/Indexer.h
===================================================================
--- src/SymTab/Indexer.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Indexer.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -16,8 +16,10 @@
 #pragma once
 
-#include <list>
-#include <string>
+#include <iosfwd>             // for ostream
+#include <list>               // for list
+#include <string>             // for string
 
-#include "SynTree/Visitor.h"
+#include "SynTree/Visitor.h"  // for Visitor
+#include "SynTree/SynTree.h"  // for AST nodes
 
 namespace SymTab {
@@ -125,4 +127,5 @@
 
 		struct Impl;
+
 		Impl *tables;         ///< Copy-on-write instance of table data structure
 		unsigned long scope;  ///< Scope index of this pointer
Index: src/SymTab/Mangler.cc
===================================================================
--- src/SymTab/Mangler.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Mangler.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -13,19 +13,19 @@
 // Update Count     : 21
 //
-
-#include <cassert>
-#include <string>
-#include <algorithm>
-#include <iterator>
-#include <functional>
-#include <set>
-
-#include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "SynTree/Statement.h"
 #include "Mangler.h"
-#include "CodeGen/OperatorTable.h"
+
+#include <algorithm>                // for copy, transform
+#include <cassert>                  // for assert, assertf
+#include <functional>               // for const_mem_fun_t, mem_fun
+#include <iterator>                 // for ostream_iterator, back_insert_ite...
+#include <list>                     // for _List_iterator, list, _List_const...
+#include <string>                   // for string, operator<<, basic_string
+
+#include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup
+#include "Common/utility.h"         // for toString
+#include "Parser/LinkageSpec.h"     // for Spec, isOverridable, AutoGen, Int...
+#include "SynTree/Declaration.h"    // for TypeDecl, DeclarationWithType
+#include "SynTree/Expression.h"     // for TypeExpr, Expression, operator<<
+#include "SynTree/Type.h"           // for Type, ReferenceToType, Type::Fora...
 
 namespace SymTab {
Index: src/SymTab/Mangler.h
===================================================================
--- src/SymTab/Mangler.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Mangler.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Mangler.h -- 
+// Mangler.h --
 //
 // Author           : Richard C. Bilson
@@ -16,7 +16,11 @@
 #pragma once
 
-#include <sstream>
-#include "SynTree/SynTree.h"
-#include "SynTree/Visitor.h"
+#include <map>                // for map, map<>::value_compare
+#include <sstream>            // for ostringstream
+#include <string>             // for string
+#include <utility>            // for pair
+
+#include "SynTree/SynTree.h"  // for Types
+#include "SynTree/Visitor.h"  // for Visitor, maybeAccept
 
 namespace SymTab {
@@ -47,5 +51,5 @@
 		virtual void visit( ZeroType *zeroType );
 		virtual void visit( OneType *oneType );
-  
+
 		std::string get_mangleName() { return mangleName.str(); }
 	  private:
@@ -57,12 +61,12 @@
 		bool mangleOverridable;         ///< Specially mangle overridable built-in methods
 		bool typeMode;                  ///< Produce a unique mangled name for a type
-  
+
 		Mangler( bool mangleOverridable, bool typeMode );
 		Mangler( const Mangler & );
-  
+
 		void mangleDecl( DeclarationWithType *declaration );
 		void mangleRef( ReferenceToType *refType, std::string prefix );
 		void mangleGenericRef( ReferenceToType *refType, std::string prefix );
-  
+
 		void printQualifiers( Type *type );
 	}; // Mangler
Index: src/SymTab/TypeEquality.cc
===================================================================
--- src/SymTab/TypeEquality.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/TypeEquality.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TypeEquality.cc -- 
+// TypeEquality.cc --
 //
 // Author           : Rob Schluntz
@@ -13,19 +13,20 @@
 // Update Count     : 37
 //
-
-#include <list>
-#include <iterator>
-#include "Validate.h"
-#include "SynTree/Visitor.h"
-#include "SynTree/Type.h"
-#include "SynTree/Statement.h"
-#include "SynTree/TypeSubstitution.h"
-#include "Indexer.h"
 #include "TypeEquality.h"
+
+#include <cassert>                // for assert
+#include <list>                   // for list, list<>::iterator, _List_iterator
+#include <string>                 // for operator==, string, basic_string
+
+#include "SynTree/Constant.h"     // for Constant
+#include "SynTree/Declaration.h"  // for DeclarationWithType
+#include "SynTree/Expression.h"   // for ConstantExpr, Expression
+#include "SynTree/Type.h"         // for Type, ArrayType, FunctionType, Enum...
+#include "SynTree/Visitor.h"      // for Visitor
 
 namespace SymTab {
 	class TypeEquality : public Visitor {
   public:
-		TypeEquality( Type * other, bool vlaErr ) : result( true ), other( other ), 
+		TypeEquality( Type * other, bool vlaErr ) : result( true ), other( other ),
 			vlaErr( vlaErr ) {}
 		bool result;
@@ -71,5 +72,5 @@
 		handleQualifiers( basicType );
 		if ( BasicType * bt = dynamic_cast< BasicType * >( other ) ) {
-			result = result && basicType->get_kind() == bt->get_kind(); 
+			result = result && basicType->get_kind() == bt->get_kind();
 		} else {
 			result = false;
@@ -98,5 +99,5 @@
 
 			if ( vlaErr ) {
-				// useful for comparing typedef types - in this case, we 
+				// useful for comparing typedef types - in this case, we
 				// want types to appear distinct if either is a VLA type
 				if ( arrayType->get_isVarLen() || at->get_isVarLen() ) {
@@ -146,5 +147,5 @@
 
 			// parameter types must be equivalent
-			it1 = funcType->get_parameters().begin(); 
+			it1 = funcType->get_parameters().begin();
 			it2 = ft->get_parameters().begin();
 			for ( ; it1 != funcType->get_parameters().end(); ++it1, ++it2 ) {
Index: src/SymTab/TypeEquality.h
===================================================================
--- src/SymTab/TypeEquality.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/TypeEquality.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TypeEquality.h -- 
+// TypeEquality.h --
 //
 // Author           : Rob Schluntz
@@ -14,8 +14,10 @@
 //
 
+class Type;
+
 namespace SymTab {
   // compare types t1 and t2 for equality
-  // if vlaErr is true, then if at least one of the types is a 
-  // variable-length array type, then the result will be false 
+  // if vlaErr is true, then if at least one of the types is a
+  // variable-length array type, then the result will be false
   bool typeEquals( Type * t1, Type * t2, bool vlaErr = false );
 } // namespace SymTab
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Validate.cc	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -38,39 +38,41 @@
 //   definition occurs later in the input.
 
-#include <algorithm>
-#include <iterator>
-#include <list>
-
-#include "CodeGen/CodeGenerator.h"
-
-#include "Common/PassVisitor.h"
-#include "Common/ScopedMap.h"
-#include "Common/UniqueName.h"
-#include "Common/utility.h"
-
-#include "Concurrency/Keywords.h"
-
-#include "GenPoly/DeclMutator.h"
-
-#include "InitTweak/InitTweak.h"
-
-#include "AddVisit.h"
-#include "Autogen.h"
-#include "FixFunction.h"
-// #include "ImplementationType.h"
-#include "Indexer.h"
-#include "MakeLibCfa.h"
-#include "TypeEquality.h"
 #include "Validate.h"
 
-#include "ResolvExpr/typeops.h"
-
-#include "SynTree/Attribute.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Mutator.h"
-#include "SynTree/Statement.h"
-#include "SynTree/Type.h"
-#include "SynTree/TypeSubstitution.h"
-#include "SynTree/Visitor.h"
+#include <cstddef>                     // for size_t
+#include <algorithm>                   // for move, transform
+#include <cassert>                     // for safe_dynamic_cast, assertf
+#include <iterator>                    // for back_inserter, inserter, back_...
+#include <list>                        // for list, _List_iterator, list<>::...
+#include <map>                         // for _Rb_tree_iterator, map, map<>:...
+#include <memory>                      // for unique_ptr, allocator
+#include <string>                      // for string, operator+, operator==
+#include <tuple>                       // for get
+#include <utility>                     // for pair, make_pair
+
+#include "AddVisit.h"                  // for addVisit
+#include "Autogen.h"                   // for SizeType, autogenerateRoutines
+#include "CodeGen/CodeGenerator.h"     // for genName
+#include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
+#include "Common/ScopedMap.h"          // for ScopedMap<>::const_iterator
+#include "Common/SemanticError.h"      // for SemanticError
+#include "Common/UniqueName.h"         // for UniqueName
+#include "Common/utility.h"            // for operator+, cloneAll, deleteAll
+#include "Concurrency/Keywords.h"      // for applyKeywords, implementMutexF...
+#include "FixFunction.h"               // for FixFunction
+#include "Indexer.h"                   // for Indexer
+#include "InitTweak/InitTweak.h"       // for isCtorDtor, isCtorDtorAssign
+#include "Parser/LinkageSpec.h"        // for C, Cforall
+#include "ResolvExpr/typeops.h"        // for extractResultType, typesCompat...
+#include "SynTree/Attribute.h"         // for Attribute
+#include "SynTree/Constant.h"          // for Constant
+#include "SynTree/Declaration.h"       // for EnumDecl, StructDecl, UnionDecl
+#include "SynTree/Expression.h"        // for TypeExpr, CompoundLiteralExpr
+#include "SynTree/Initializer.h"       // for ListInit, Initializer, noDesig...
+#include "SynTree/Mutator.h"           // for mutateAll, Mutator
+#include "SynTree/Statement.h"         // for CompoundStmt, DeclStmt, Return...
+#include "SynTree/Type.h"              // for Type, TypeInstType, TraitInstType
+#include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, applySubstit...
+#include "SynTree/Visitor.h"           // for acceptAll, Visitor
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -605,5 +607,5 @@
 		// a return statement in a void-returning function in C. The expression is treated as if it
 		// were cast to void.
-		if ( returnStmt->get_expr() == NULL && returnVals.size() != 0 ) {
+		if ( ! returnStmt->get_expr() && returnVals.size() != 0 ) {
 			throw SemanticError( "Non-void function returns no values: " , returnStmt );
 		}
@@ -836,5 +838,5 @@
 	void validateGeneric( Aggr * inst ) {
 		std::list< TypeDecl * > * params = inst->get_baseParameters();
-		if ( params != NULL ) {
+		if ( params ) {
 			std::list< Expression * > & args = inst->get_parameters();
 
@@ -937,5 +939,5 @@
 	void ArrayLength::previsit( ObjectDecl * objDecl ) {
 		if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
-			if ( at->get_dimension() != nullptr ) return;
+			if ( at->get_dimension() ) return;
 			if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->get_init() ) ) {
 				at->set_dimension( new ConstantExpr( Constant::from_ulong( init->get_initializers().size() ) ) );
Index: src/SymTab/Validate.h
===================================================================
--- src/SymTab/Validate.h	(revision ea91c4249b368dd12df6d63ca49b3a4beafb8d89)
+++ src/SymTab/Validate.h	(revision 33218c6845f9825be5a63043ef89bb8a0a80d009)
@@ -17,5 +17,8 @@
 #pragma once
 
-#include "SynTree/SynTree.h"
+#include <list>  // for list
+
+class Declaration;
+class Type;
 
 namespace SymTab {
