Index: src/AST/Decl.hpp
===================================================================
--- src/AST/Decl.hpp	(revision cf3da24e082d37af956e24da04627a0f26be77f7)
+++ src/AST/Decl.hpp	(revision a1da039d49b92f720bc279fc8e82273197880e11)
@@ -125,5 +125,5 @@
 
 /// Object declaration `int foo()`
-class FunctionDecl : public DeclWithType {
+class FunctionDecl final : public DeclWithType {
 public:
 	std::vector<ptr<TypeDecl>> type_params;
@@ -314,7 +314,9 @@
 class EnumDecl final : public AggregateDecl {
 public:
-	bool isTyped; // isTyped indicated if the enum has a declaration like:
+	// isTyped indicated if the enum has a declaration like:
 	// enum (type_optional) Name {...}
-	ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
+	bool isTyped;
+	// if isTyped == true && base.get() == nullptr, it is a "void" type enum
+	ptr<Type> base;
 	enum class EnumHiding { Visible, Hide } hide;
 
@@ -374,10 +376,10 @@
 
 /// Assembly declaration: `asm ... ( "..." : ... )`
-class AsmDecl : public Decl {
+class AsmDecl final : public Decl {
 public:
 	ptr<AsmStmt> stmt;
 
 	AsmDecl( const CodeLocation & loc, AsmStmt * stmt )
-	: Decl( loc, "", {}, {} ), stmt(stmt) {}
+	: Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
 
 	const AsmDecl * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -388,10 +390,10 @@
 
 /// C-preprocessor directive `#...`
-class DirectiveDecl : public Decl {
+class DirectiveDecl final : public Decl {
 public:
 	ptr<DirectiveStmt> stmt;
 
 	DirectiveDecl( const CodeLocation & loc, DirectiveStmt * stmt )
-	: Decl( loc, "", {}, {} ), stmt(stmt) {}
+	: Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
 
 	const DirectiveDecl * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -402,5 +404,5 @@
 
 /// Static Assertion `_Static_assert( ... , ... );`
-class StaticAssertDecl : public Decl {
+class StaticAssertDecl final : public Decl {
 public:
 	ptr<Expr> cond;
@@ -408,5 +410,5 @@
 
 	StaticAssertDecl( const CodeLocation & loc, const Expr * condition, const ConstantExpr * msg )
-	: Decl( loc, "", {}, {} ), cond( condition ), msg( msg ) {}
+	: Decl( loc, "", {}, Linkage::C ), cond( condition ), msg( msg ) {}
 
 	const StaticAssertDecl * accept( Visitor & v ) const override { return v.visit( this ); }
Index: src/AST/Stmt.hpp
===================================================================
--- src/AST/Stmt.hpp	(revision cf3da24e082d37af956e24da04627a0f26be77f7)
+++ src/AST/Stmt.hpp	(revision a1da039d49b92f720bc279fc8e82273197880e11)
@@ -28,5 +28,5 @@
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
 #define MUTATE_FRIEND													\
-    template<typename node_t> friend node_t * mutate(const node_t * node); \
+	template<typename node_t> friend node_t * mutate(const node_t * node); \
 	template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
@@ -340,5 +340,5 @@
 
 	CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-			   const Stmt * body )
+			const Stmt * body )
 		: StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
 
@@ -380,7 +380,7 @@
 // Base class of WaitFor/WaitUntil statements
 // form: KEYWORD(...) ... timeout(...) ... else ...
-class WaitStmt : public Stmt { 
-  public:
-    ptr<Expr> timeout_time;
+class WaitStmt : public Stmt {
+  public:
+	ptr<Expr> timeout_time;
 	ptr<Stmt> timeout_stmt;
 	ptr<Expr> timeout_cond;
@@ -388,9 +388,9 @@
 	ptr<Expr> else_cond;
 
-    WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+	WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
 		: Stmt(loc, std::move(labels)) {}
 
   private:
-    WaitStmt * clone() const override = 0;
+	WaitStmt * clone() const override = 0;
 	MUTATE_FRIEND
 };
@@ -444,40 +444,40 @@
 class WaitUntilStmt final : public WaitStmt {
   public:
-    // Non-ast node used during compilation to store data needed to generate predicates
-    //    and set initial status values for clauses
-    // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
-    struct ClauseNode { 
-        enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
-        // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
-
-        ClauseNode * left;
-        ClauseNode * right;
-        WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
-
-        bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
-        bool whenState;     // used to track if when_cond is toggled on or off for generating init values
-        bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
-
-        ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
-            : op(op), left(left), right(right), leaf(nullptr), 
-            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
-        ClauseNode( Op op, WhenClause * leaf )
-            : op(op), left(nullptr), right(nullptr), leaf(leaf),
-            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
-        ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
-        
-        ~ClauseNode() {
-            if ( left ) delete left;
-            if ( right ) delete right;
-        }
-    };
+	// Non-ast node used during compilation to store data needed to generate predicates
+	//    and set initial status values for clauses
+	// Used to create a tree corresponding to the structure of the clauses in a WaitUntil
+	struct ClauseNode {
+		enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
+		// LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
+
+		ClauseNode * left;
+		ClauseNode * right;
+		WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
+
+		bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
+		bool whenState;     // used to track if when_cond is toggled on or off for generating init values
+		bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
+
+		ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
+			: op(op), left(left), right(right), leaf(nullptr),
+			ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+		ClauseNode( Op op, WhenClause * leaf )
+			: op(op), left(nullptr), right(nullptr), leaf(leaf),
+			ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+		ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
+
+		~ClauseNode() {
+			if ( left ) delete left;
+			if ( right ) delete right;
+		}
+	};
 
 	std::vector<ptr<WhenClause>> clauses;
-    ClauseNode * predicateTree;
+	ClauseNode * predicateTree;
 
 	WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
 		: WaitStmt(loc, std::move(labels)) {}
 
-    ~WaitUntilStmt() { delete predicateTree; }
+	~WaitUntilStmt() { delete predicateTree; }
 
 	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -522,5 +522,5 @@
 	std::vector<ptr<Expr>> mutexObjs;
 
-	MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
+	MutexStmt( const CodeLocation & loc, const Stmt * stmt,
 			   const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
 		: Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}