//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Keywords.cpp -- Implement concurrency constructs from their keywords.
//
// Author           : Andrew Beach
// Created On       : Tue Nov 16  9:53:00 2021
// Last Modified By : Peter A. Buhr
// Last Modified On : Fri Jan 24 18:33:02 2025
// Update Count     : 14
//

#include "Concurrency/Keywords.hpp"

#include <iostream>

#include "AST/Copy.hpp"
#include "AST/Decl.hpp"
#include "AST/Expr.hpp"
#include "AST/Inspect.hpp"
#include "AST/Pass.hpp"
#include "AST/Stmt.hpp"
#include "AST/DeclReplacer.hpp"
#include "AST/TranslationUnit.hpp"
#include "CodeGen/OperatorTable.hpp"
#include "Common/Examine.hpp"
#include "Common/Utility.hpp"
#include "Common/UniqueName.hpp"
#include "ControlStruct/LabelGenerator.hpp"
#include "InitTweak/InitTweak.hpp"
#include "Virtual/Tables.hpp"

namespace Concurrency {

namespace {

// --------------------------------------------------------------------------
// Loose Helper Functions:

/// Detect threads constructed with the keyword thread.
bool isThread( const ast::DeclWithType * decl ) {
	auto baseType = decl->get_type()->stripDeclarator();
	auto instType = dynamic_cast<const ast::StructInstType *>( baseType );
	if ( nullptr == instType ) { return false; }
	return instType->base->is_thread();
}

/// Get the virtual type id if given a type name.
std::string typeIdType( std::string const & exception_name ) {
	return exception_name.empty() ? std::string()
		: Virtual::typeIdType( exception_name );
}

/// Get the vtable type name if given a type name.
std::string vtableTypeName( std::string const & exception_name ) {
	return exception_name.empty() ? std::string()
		: Virtual::vtableTypeName( exception_name );
}

static ast::Type * mutate_under_references( ast::ptr<ast::Type>& type ) {
	ast::Type * mutType = type.get_and_mutate();
	for ( ast::ReferenceType * mutRef
		; (mutRef = dynamic_cast<ast::ReferenceType *>( mutType ))
		; mutType = mutRef->base.get_and_mutate() );
	return mutType;
}

// Describe that it adds the generic parameters and the uses of the generic parameters on the
// function and first "this" argument.
ast::FunctionDecl * fixupGenerics(
		const ast::FunctionDecl * func, const ast::StructDecl * decl ) {
	const CodeLocation & location = decl->location;
	// We have to update both the declaration
	auto mutFunc = ast::mutate( func );
	auto mutType = mutFunc->type.get_and_mutate();

	if ( decl->params.empty() ) {
		return mutFunc;
	}

	assert( 0 != mutFunc->params.size() );
	assert( 0 != mutType->params.size() );

	// Add the "forall" clause information.
	for ( const ast::ptr<ast::TypeDecl> & typeParam : decl->params ) {
		auto typeDecl = ast::deepCopy( typeParam );
		mutFunc->type_params.push_back( typeDecl );
		mutType->forall.push_back( new ast::TypeInstType( typeDecl ) );
		for ( auto & assertion : typeDecl->assertions ) {
			mutFunc->assertions.push_back( assertion );
			mutType->assertions.emplace_back(
				new ast::VariableExpr( location, assertion ) );
		}
		typeDecl->assertions.clear();
	}

	// Even chain_mutate is not powerful enough for this:
	ast::ptr<ast::Type>& paramType = strict_dynamic_cast<ast::ObjectDecl *>(
		mutFunc->params[0].get_and_mutate() )->type;
	auto paramTypeInst = strict_dynamic_cast<ast::StructInstType *>(
		mutate_under_references( paramType ) );
	auto typeParamInst = strict_dynamic_cast<ast::StructInstType *>(
		mutate_under_references( mutType->params[0] ) );

	for ( const ast::ptr<ast::TypeDecl> & typeDecl : mutFunc->type_params ) {
		paramTypeInst->params.push_back(
			new ast::TypeExpr( location, new ast::TypeInstType( typeDecl ) ) );
		typeParamInst->params.push_back(
			new ast::TypeExpr( location, new ast::TypeInstType( typeDecl ) ) );
	}

	return mutFunc;
}

// --------------------------------------------------------------------------

// This type describes the general information used to transform a generator, coroutine, monitor, or
// thread aggregate kind.  A pass is made over the AST in ConcurrentSueKeyword::postvisit looking
// for each of these kinds. When found, this data structure is filled in with the information from
// the specific structures below, and handleStruct is called to perform the common changes that
// augment the aggregate kind with fields and generate appropriate companion routines.  The location
// of any extra fields is specified in addField.

struct ConcurrentSueKeyword : public ast::WithDeclsToAdd {
	ConcurrentSueKeyword(
		std::string&& type_name, std::string&& field_name,
		std::string&& getter_name, std::string&& context_error,
		std::string&& exception_name,
		bool needs_main, ast::AggregateDecl::Aggregate cast_target
	) :
		type_name( type_name ), field_name( field_name ),
		getter_name( getter_name ), context_error( context_error ),
		exception_name( exception_name ),
		typeid_name( typeIdType( exception_name ) ),
		vtable_name( vtableTypeName( exception_name ) ),
		needs_main( needs_main ), cast_target( cast_target )
	{}

	virtual ~ConcurrentSueKeyword() {}

	const ast::Decl * postvisit( const ast::StructDecl * decl );
	const ast::DeclWithType * postvisit( const ast::FunctionDecl * decl );
	const ast::Expr * postvisit( const ast::KeywordCastExpr * expr );

	struct StructAndField {
		const ast::StructDecl * decl;
		const ast::ObjectDecl * field;
	};

	const ast::StructDecl * handleStruct( const ast::StructDecl * );
	void handleMain( const ast::FunctionDecl *, const ast::StructInstType * );
	void addTypeId( const ast::StructDecl * );
	void addVtableForward( const ast::StructDecl * );
	const ast::FunctionDecl * forwardDeclare( const ast::StructDecl * );
	StructAndField addField( const ast::StructDecl * );
	void addGetRoutines( const ast::ObjectDecl *, const ast::FunctionDecl * );
	void addLockUnlockRoutines( const ast::StructDecl * );

private:
	const std::string type_name;
	const std::string field_name;
	const std::string getter_name;
	const std::string context_error;
	const std::string exception_name;
	const std::string typeid_name;
	const std::string vtable_name;
	const bool needs_main;
	const ast::AggregateDecl::Aggregate cast_target;

	const ast::StructDecl   * type_decl = nullptr;
	const ast::FunctionDecl * dtor_decl = nullptr;
	const ast::StructDecl * except_decl = nullptr;
	const ast::StructDecl * typeid_decl = nullptr;
	const ast::StructDecl * vtable_decl = nullptr;

};

// Handles generator type declarations:
//
// generator MyGenerator {                   struct MyGenerator {
//                                =>             int __generator_state;
//    int data;                                  int data;
//    a_struct_t more_data;                      a_struct_t more_data;
// };                                        };
//
struct GeneratorKeyword final : public ConcurrentSueKeyword {
	GeneratorKeyword() : ConcurrentSueKeyword(
		"generator$",
		"__generator_state",
		"get_generator",
		"Unable to find builtin type generator$\n",
		"",
		true,
		ast::AggregateDecl::Generator )
	{}

	virtual ~GeneratorKeyword() {}
};

// Handles coroutine type declarations:
//
// coroutine MyCoroutine {                   struct MyCoroutine {
//                                =>             coroutine$ __cor_d;
//    int data;                                  int data;
//    a_struct_t more_data;                      a_struct_t more_data;
// };                                        };
//                                           static inline coroutine$ * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
//
struct CoroutineKeyword final : public ConcurrentSueKeyword {
	CoroutineKeyword() : ConcurrentSueKeyword(
		"coroutine$",
		"__cor",
		"get_coroutine",
		"coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
		"CoroutineCancelled",
		true,
		ast::AggregateDecl::Coroutine )
	{}

	virtual ~CoroutineKeyword() {}
};

// Handles monitor type declarations:
//
// monitor MyMonitor {                       struct MyMonitor {
//                                =>             monitor$ __mon_d;
//    int data;                                  int data;
//    a_struct_t more_data;                      a_struct_t more_data;
// };                                        };
//                                           static inline monitor$ * get_coroutine( MyMonitor * this ) {
//                                               return &this->__cor_d;
//                                           }
//                                           void lock(MyMonitor & this) {
//                                               lock(get_monitor(this));
//                                           }
//                                           void unlock(MyMonitor & this) {
//                                               unlock(get_monitor(this));
//                                           }
//
struct MonitorKeyword final : public ConcurrentSueKeyword {
	MonitorKeyword() : ConcurrentSueKeyword(
		"monitor$",
		"__mon",
		"get_monitor",
		"monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
		"",
		false,
		ast::AggregateDecl::Monitor )
	{}

	virtual ~MonitorKeyword() {}
};

// Handles thread type declarations:
//
// thread Mythread {                         struct MyThread {
//                                =>             thread$ __thrd_d;
//    int data;                                  int data;
//    a_struct_t more_data;                      a_struct_t more_data;
// };                                        };
//                                           static inline thread$ * get_thread( MyThread * this ) { return &this->__thrd_d; }
//
struct ThreadKeyword final : public ConcurrentSueKeyword {
	ThreadKeyword() : ConcurrentSueKeyword(
		"thread$",
		"__thrd",
		"get_thread",
		"thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
		"ThreadCancelled",
		true,
		ast::AggregateDecl::Thread )
	{}

	virtual ~ThreadKeyword() {}
};

const ast::Decl * ConcurrentSueKeyword::postvisit(
		const ast::StructDecl * decl ) {
	if ( !decl->body ) {
		return decl;
	} else if ( cast_target == decl->kind ) {
		return handleStruct( decl );
	} else if ( type_name == decl->name ) {
		assert( !type_decl );
		type_decl = decl;
	} else if ( exception_name == decl->name ) {
		assert( !except_decl );
		except_decl = decl;
	} else if ( typeid_name == decl->name ) {
		assert( !typeid_decl );
		typeid_decl = decl;
	} else if ( vtable_name == decl->name ) {
		assert( !vtable_decl );
		vtable_decl = decl;
	}
	return decl;
}

// Try to get the full definition, but raise an error on conflicts.
const ast::FunctionDecl * getDefinition(
		const ast::FunctionDecl * old_decl,
		const ast::FunctionDecl * new_decl ) {
	if ( !new_decl->stmts ) {
		return old_decl;
	} else if ( !old_decl->stmts ) {
		return new_decl;
	} else {
		assert( !old_decl->stmts || !new_decl->stmts );
		return nullptr;
	}
}

const ast::DeclWithType * ConcurrentSueKeyword::postvisit(
		const ast::FunctionDecl * decl ) {
	if ( type_decl && isDestructorFor( decl, type_decl ) ) {
		// Check for forward declarations, try to get the full definition.
		dtor_decl = (dtor_decl) ? getDefinition( dtor_decl, decl ) : decl;
	} else if ( !vtable_name.empty() && decl->has_body() ) {
		if (const ast::DeclWithType * param = isMainFor( decl, cast_target )) {
			if ( !vtable_decl ) {
				SemanticError( decl, context_error );
			}
			// Should be safe because of isMainFor.
			const ast::StructInstType * struct_type =
				static_cast<const ast::StructInstType *>(
					static_cast<const ast::ReferenceType *>(
						param->get_type() )->base.get() );

			handleMain( decl, struct_type );
		}
	}
	return decl;
}

const ast::Expr * ConcurrentSueKeyword::postvisit(
		const ast::KeywordCastExpr * expr ) {
	if ( cast_target == expr->target ) {
		// Convert `(thread &)ex` to `(thread$ &)*get_thread(ex)`, etc.
		if ( !type_decl || !dtor_decl ) {
			SemanticError( expr, context_error );
		}
		assert( nullptr == expr->result );
		auto cast = ast::mutate( expr );
		cast->result = new ast::ReferenceType( new ast::StructInstType( type_decl ) );
		cast->concrete_target.field  = field_name;
		cast->concrete_target.getter = getter_name;
		return cast;
	}
	return expr;
}

const ast::StructDecl * ConcurrentSueKeyword::handleStruct(
		const ast::StructDecl * decl ) {
	assert( decl->body );

	if ( !type_decl || !dtor_decl ) {
		SemanticError( decl, context_error );
	}

	if ( !exception_name.empty() ) {
		if ( !typeid_decl || !vtable_decl ) {
			SemanticError( decl, context_error );
		}
		addTypeId( decl );
		addVtableForward( decl );
	}

	const ast::FunctionDecl * func = forwardDeclare( decl );
	StructAndField addFieldRet = addField( decl );
	decl = addFieldRet.decl;
	const ast::ObjectDecl * field = addFieldRet.field;

	addGetRoutines( field, func );
	// Add routines to monitors for use by mutex stmt.
	if ( ast::AggregateDecl::Monitor == cast_target ) {
		addLockUnlockRoutines( decl );
	}

	return decl;
}

void ConcurrentSueKeyword::handleMain(
		const ast::FunctionDecl * decl, const ast::StructInstType * type ) {
	assert( vtable_decl );
	assert( except_decl );

	const CodeLocation & location = decl->location;

	std::vector<ast::ptr<ast::Expr>> poly_args = {
		new ast::TypeExpr( location, type ),
	};
	ast::ObjectDecl * vtable_object = Virtual::makeVtableInstance(
		location,
		"_default_vtable_object_declaration",
		new ast::StructInstType( vtable_decl, copy( poly_args ) ),
		type,
		nullptr
	);
	declsToAddAfter.push_back( vtable_object );
	declsToAddAfter.push_back(
		new ast::ObjectDecl(
			location,
			Virtual::concurrentDefaultVTableName(),
			new ast::ReferenceType( vtable_object->type, ast::CV::Const ),
			new ast::SingleInit( location,
				new ast::VariableExpr( location, vtable_object ) )
		)
	);
	declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
		location,
		vtable_object,
		new ast::StructInstType( except_decl, copy( poly_args ) )
	) );
}

void ConcurrentSueKeyword::addTypeId( const ast::StructDecl * decl ) {
	assert( typeid_decl );
	const CodeLocation & location = decl->location;

	ast::StructInstType * typeid_type =
		new ast::StructInstType( typeid_decl, ast::CV::Const );
	typeid_type->params.push_back(
		new ast::TypeExpr( location, new ast::StructInstType( decl ) ) );
	declsToAddBefore.push_back(
		Virtual::makeTypeIdInstance( location, typeid_type ) );
	// If the typeid_type is going to be kept, the other reference will have been made by now, but
	// we also get to avoid extra mutates.
	ast::ptr<ast::StructInstType> typeid_cleanup = typeid_type;
}

void ConcurrentSueKeyword::addVtableForward( const ast::StructDecl * decl ) {
	assert( vtable_decl );
	const CodeLocation& location = decl->location;

	std::vector<ast::ptr<ast::Expr>> poly_args = {
		new ast::TypeExpr( location, new ast::StructInstType( decl ) ),
	};
	declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
		location,
		new ast::StructInstType( vtable_decl, copy( poly_args ) ),
		new ast::StructInstType( except_decl, copy( poly_args ) )
	) );
	ast::ObjectDecl * vtable_object = Virtual::makeVtableForward(
		location,
		"_default_vtable_object_declaration",
		new ast::StructInstType( vtable_decl, std::move( poly_args ) )
	);
	declsToAddBefore.push_back( vtable_object );
	declsToAddBefore.push_back(
		new ast::ObjectDecl(
			location,
			Virtual::concurrentDefaultVTableName(),
			new ast::ReferenceType( vtable_object->type, ast::CV::Const ),
			nullptr,
			ast::Storage::Extern,
			ast::Linkage::Cforall
		)
	);
}

const ast::FunctionDecl * ConcurrentSueKeyword::forwardDeclare(
		const ast::StructDecl * decl ) {
	const CodeLocation & location = decl->location;

	ast::StructDecl * forward = ast::deepCopy( decl );
	{
		// If removing members makes ref-count go to zero, do not free.
		ast::ptr<ast::StructDecl> forward_ptr = forward;
		forward->body = false;
		forward->members.clear();
		forward_ptr.release();
	}

	ast::ObjectDecl * this_decl = new ast::ObjectDecl(
		location,
		"this",
		new ast::ReferenceType( new ast::StructInstType( decl ) )
	);

	ast::ObjectDecl * ret_decl = new ast::ObjectDecl(
		location,
		"ret",
		new ast::PointerType( new ast::StructInstType( type_decl ) )
	);

	ast::FunctionDecl * get_decl = new ast::FunctionDecl(
		location,
		getter_name,
		{ this_decl }, // params
		{ ret_decl }, // returns
		nullptr, // stmts
		ast::Storage::Static,
		ast::Linkage::Cforall,
		{ new ast::Attribute( "const" ) },
		ast::Function::Inline
	);
	get_decl = fixupGenerics( get_decl, decl );

	ast::FunctionDecl * main_decl = nullptr;
	if ( needs_main ) {
		// `this_decl` is copied here because the original was used above.
		main_decl = new ast::FunctionDecl(
			location,
			"main",
			{ ast::deepCopy( this_decl ) },
			{},
			nullptr,
			ast::Storage::Classes(),
			ast::Linkage::Cforall
		);
		main_decl = fixupGenerics( main_decl, decl );
	}

	declsToAddBefore.push_back( forward );
	if ( needs_main ) declsToAddBefore.push_back( main_decl );
	declsToAddBefore.push_back( get_decl );

	return get_decl;
}

ConcurrentSueKeyword::StructAndField ConcurrentSueKeyword::addField(
		const ast::StructDecl * decl ) {
	const CodeLocation & location = decl->location;

	ast::ObjectDecl * field = new ast::ObjectDecl(
		location,
		field_name,
		new ast::StructInstType( type_decl )
	);

	auto mutDecl = ast::mutate( decl );
	// Insert at start of special aggregate structures => front of vector
	mutDecl->members.insert( mutDecl->members.begin(), field );

	return {mutDecl, field};
}

void ConcurrentSueKeyword::addGetRoutines(
		const ast::ObjectDecl * field, const ast::FunctionDecl * forward ) {
	// Clone the signature and then build the body.
	ast::FunctionDecl * decl = ast::deepCopy( forward );

	// Say it is generated at the "same" places as the forward declaration.
	const CodeLocation & location = decl->location;

	const ast::DeclWithType * param = decl->params.front();
	ast::Stmt * stmt = new ast::ReturnStmt( location,
		new ast::AddressExpr( location,
			new ast::MemberExpr( location,
				field,
				new ast::CastExpr( location,
					new ast::VariableExpr( location, param ),
					ast::deepCopy( param->get_type()->stripReferences() ),
					ast::ExplicitCast
				)
			)
		)
	);

	decl->stmts = new ast::CompoundStmt( location, { stmt } );
	declsToAddAfter.push_back( decl );
}

void ConcurrentSueKeyword::addLockUnlockRoutines(
		const ast::StructDecl * decl ) {
	// This should only be used on monitors.
	assert( ast::AggregateDecl::Monitor == cast_target );

	const CodeLocation & location = decl->location;

	// The parameter for both routines.
	ast::ObjectDecl * this_decl = new ast::ObjectDecl(
		location,
		"this",
		new ast::ReferenceType( new ast::StructInstType( decl ) )
	);

	ast::FunctionDecl * lock_decl = new ast::FunctionDecl(
		location,
		"lock",
		{
			// Copy the declaration of this.
			ast::deepCopy( this_decl ),
		},
		{ /* returns */ },
		nullptr,
		ast::Storage::Static,
		ast::Linkage::Cforall,
		{ /* attributes */ },
		ast::Function::Inline
	);
	lock_decl = fixupGenerics( lock_decl, decl );

	lock_decl->stmts = new ast::CompoundStmt( location, {
		new ast::ExprStmt( location,
			new ast::UntypedExpr( location,
				new ast::NameExpr( location, "lock" ),
				{
					new ast::UntypedExpr( location,
						new ast::NameExpr( location, "get_monitor" ),
						{ new ast::VariableExpr( location,
							InitTweak::getParamThis( lock_decl ) ) }
					)
				}
			)
		)
	} );

	ast::FunctionDecl * unlock_decl = new ast::FunctionDecl(
		location,
		"unlock",
		{
			// Last use, consume the declaration of this.
			this_decl,
		},
		{ /* returns */ },
		nullptr,
		ast::Storage::Static,
		ast::Linkage::Cforall,
		{ /* attributes */ },
		ast::Function::Inline
	);
	unlock_decl = fixupGenerics( unlock_decl, decl );

	unlock_decl->stmts = new ast::CompoundStmt( location, {
		new ast::ExprStmt( location,
			new ast::UntypedExpr( location,
				new ast::NameExpr( location, "unlock" ),
				{
					new ast::UntypedExpr( location,
						new ast::NameExpr( location, "get_monitor" ),
						{ new ast::VariableExpr( location,
							InitTweak::getParamThis( unlock_decl ) ) }
					)
				}
			)
		)
	} );

	declsToAddAfter.push_back( lock_decl );
	declsToAddAfter.push_back( unlock_decl );
}


// --------------------------------------------------------------------------
struct SuspendKeyword final :
		public ast::WithStmtsToAdd, public ast::WithGuards {
	SuspendKeyword() = default;
	virtual ~SuspendKeyword() = default;

	void previsit( const ast::FunctionDecl * );
	const ast::DeclWithType * postvisit( const ast::FunctionDecl * );
	const ast::Stmt * postvisit( const ast::SuspendStmt * );

private:
	bool is_real_suspend( const ast::FunctionDecl * );

	const ast::Stmt * make_generator_suspend( const ast::SuspendStmt * );
	const ast::Stmt * make_coroutine_suspend( const ast::SuspendStmt * );

	struct LabelPair {
		ast::Label obj;
		int idx;
	};

	LabelPair make_label(const ast::Stmt * stmt ) {
		labels.push_back( ControlStruct::newLabel( "generator", stmt ) );
		return { labels.back(), int(labels.size()) };
	}

	const ast::DeclWithType * in_generator = nullptr;
	const ast::FunctionDecl * decl_suspend = nullptr;
	std::vector<ast::Label> labels;
};

void SuspendKeyword::previsit( const ast::FunctionDecl * decl ) {
	GuardValue( in_generator ); in_generator = nullptr;

	// If it is the real suspend, grab it if we don't have one already.
	if ( is_real_suspend( decl ) ) {
		decl_suspend = decl_suspend ? decl_suspend : decl;
		return;
	}

	// Otherwise check if this is a generator main and, if so, handle it.
	auto param = isMainFor( decl, ast::AggregateDecl::Generator );
	if ( !param ) return;

	if ( 0 != decl->returns.size() ) {
		SemanticError( decl->location, "Generator main must return void." );
	}

	in_generator = param;
	GuardValue( labels ); labels.clear();
}

const ast::DeclWithType * SuspendKeyword::postvisit(
		const ast::FunctionDecl * decl ) {
	// Only modify a full definition of a generator with states.
	if ( !decl->stmts || !in_generator || labels.empty() ) return decl;

	const CodeLocation & location = decl->location;

	// Create a new function body:
	// static void * __generator_labels[] = {&&s0, &&s1, ...};
	// void * __generator_label = __generator_labels[GEN.__generator_state];
	// goto * __generator_label;
	// s0: ;
	// OLD_BODY

	// This is the null statement inserted right before the body.
	ast::NullStmt * noop = new ast::NullStmt( location );
	noop->labels.push_back( ControlStruct::newLabel( "generator", noop ) );
	const ast::Label & first_label = noop->labels.back();

	// Add each label to the init, starting with the first label.
	std::vector<ast::ptr<ast::Init>> inits = {
		new ast::SingleInit( location,
			new ast::LabelAddressExpr( location, copy( first_label ) ) ) };
	// Then go through all the stored labels, and clear the store.
	for ( auto && label : labels ) {
		inits.push_back( new ast::SingleInit( label.location,
			new ast::LabelAddressExpr( label.location, std::move( label )
			) ) );
	}
	labels.clear();
	// Then construct the initializer itself.
	auto init = new ast::ListInit( location, std::move( inits ) );

	ast::ObjectDecl * generatorLabels = new ast::ObjectDecl(
		location,
		"__generator_labels",
		new ast::ArrayType(
			new ast::PointerType( new ast::VoidType() ),
			nullptr,
			ast::FixedLen,
			ast::DynamicDim
		),
		init,
		ast::Storage::Classes(),
		ast::Linkage::AutoGen
	);

	ast::ObjectDecl * generatorLabel = new ast::ObjectDecl(
		location,
		"__generator_label",
		new ast::PointerType( new ast::VoidType() ),
		new ast::SingleInit( location,
			new ast::UntypedExpr( location,
				new ast::NameExpr( location, "?[?]" ),
				{
					// TODO: Could be a variable expr.
					new ast::NameExpr( location, "__generator_labels" ),
					new ast::UntypedMemberExpr( location,
						new ast::NameExpr( location, "__generator_state" ),
						new ast::VariableExpr( location, in_generator )
					)
				}
			)
		),
		ast::Storage::Classes(),
		ast::Linkage::AutoGen
	);

	ast::BranchStmt * theGoTo = new ast::BranchStmt(
		location, new ast::VariableExpr( location, generatorLabel )
	);

	// The noop goes here in order.

	ast::CompoundStmt * body = new ast::CompoundStmt( location, {
		{ new ast::DeclStmt( location, generatorLabels ) },
		{ new ast::DeclStmt( location, generatorLabel ) },
		{ theGoTo },
		{ noop },
		{ decl->stmts },
	} );

	auto mutDecl = ast::mutate( decl );
	mutDecl->stmts = body;
	return mutDecl;
}

const ast::Stmt * SuspendKeyword::postvisit( const ast::SuspendStmt * stmt ) {
	switch ( stmt->kind ) {
	case ast::SuspendStmt::None:
		// Use the context to determain the implicit target.
		if ( in_generator ) {
			return make_generator_suspend( stmt );
		} else {
			return make_coroutine_suspend( stmt );
		}
	case ast::SuspendStmt::Coroutine:
		return make_coroutine_suspend( stmt );
	case ast::SuspendStmt::Generator:
		// Generator suspends must be directly in a generator.
		if ( !in_generator ) SemanticError( stmt->location, "\"suspend generator\" must be used inside main of generator type." );
		return make_generator_suspend( stmt );
	}
	assert( false );
	return stmt;
}

/// Find the real/official suspend declaration.
bool SuspendKeyword::is_real_suspend( const ast::FunctionDecl * decl ) {
	return ( !decl->linkage.is_mangled
		&& 0 == decl->params.size()
		&& 0 == decl->returns.size()
		&& "__cfactx_suspend" == decl->name );
}

const ast::Stmt * SuspendKeyword::make_generator_suspend(
		const ast::SuspendStmt * stmt ) {
	assert( in_generator );
	// Target code is:
	//   GEN.__generator_state = X;
	//   THEN
	//   return;
	//   __gen_X:;

	const CodeLocation & location = stmt->location;

	LabelPair label = make_label( stmt );

	// This is the context saving statement.
	stmtsToAddBefore.push_back( new ast::ExprStmt( location,
		new ast::UntypedExpr( location,
			new ast::NameExpr( location, "?=?" ),
			{
				new ast::UntypedMemberExpr( location,
					new ast::NameExpr( location, "__generator_state" ),
					new ast::VariableExpr( location, in_generator )
				),
				ast::ConstantExpr::from_int( location, label.idx ),
			}
		)
	) );

	// The THEN component is conditional (return is not).
	if ( stmt->then ) {
		stmtsToAddBefore.push_back( stmt->then.get() );
	}
	stmtsToAddBefore.push_back( new ast::ReturnStmt( location, nullptr ) );

	// The null statement replaces the old suspend statement.
	return new ast::NullStmt( location, { label.obj } );
}

const ast::Stmt * SuspendKeyword::make_coroutine_suspend(
		const ast::SuspendStmt * stmt ) {
	// The only thing we need from the old statement is the location.
	const CodeLocation & location = stmt->location;

	if ( !decl_suspend ) {
		SemanticError( location, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>." );
	}
	if ( stmt->then ) {
		SemanticError( location, "Compound statement following coroutines is not implemented." );
	}

	return new ast::ExprStmt( location,
		new ast::UntypedExpr( location,
			ast::VariableExpr::functionPointer( location, decl_suspend ) )
	);
}

// --------------------------------------------------------------------------
struct MutexKeyword final : public ast::WithDeclsToAdd {
	const ast::FunctionDecl * postvisit( const ast::FunctionDecl * decl );
	void postvisit( const ast::StructDecl * decl );
	const ast::Stmt * postvisit( const ast::MutexStmt * stmt );

	static std::vector<const ast::DeclWithType *> findMutexArgs(
			const ast::FunctionDecl * decl, bool & first );
	static void validate( const ast::DeclWithType * decl );

	ast::CompoundStmt * addDtorStatements( const ast::FunctionDecl* func, const ast::CompoundStmt *, const std::vector<const ast::DeclWithType *> &);
	ast::CompoundStmt * addStatements( const ast::FunctionDecl* func, const ast::CompoundStmt *, const std::vector<const ast::DeclWithType *> &);
	ast::CompoundStmt * addStatements( const ast::CompoundStmt * body, const std::vector<ast::ptr<ast::Expr>> & args );
	ast::CompoundStmt * addThreadDtorStatements( const ast::FunctionDecl* func, const ast::CompoundStmt * body, const std::vector<const ast::DeclWithType *> & args );
	ast::ExprStmt * genVirtLockUnlockExpr( const std::string & fnName, ast::ptr<ast::Expr> expr, const CodeLocation & location, ast::Expr * param);
	ast::IfStmt * genTypeDiscrimLockUnlock( const std::string & fnName, const std::vector<ast::ptr<ast::Expr>> & args, const CodeLocation & location, ast::UntypedExpr * thisParam );
private:
	const ast::StructDecl * monitor_decl = nullptr;
	const ast::StructDecl * guard_decl = nullptr;
	const ast::StructDecl * dtor_guard_decl = nullptr;
	const ast::StructDecl * thread_guard_decl = nullptr;
	const ast::StructDecl * lock_guard_decl = nullptr;

	static ast::ptr<ast::Type> generic_func;

	UniqueName mutex_func_namer = UniqueName("__lock_unlock_curr");
};

const ast::FunctionDecl * MutexKeyword::postvisit(
		const ast::FunctionDecl * decl ) {
	bool is_first_argument_mutex = false;
	const std::vector<const ast::DeclWithType *> mutexArgs =
		findMutexArgs( decl, is_first_argument_mutex );
	bool const isDtor = CodeGen::isDestructor( decl->name );

	// Does this function have any mutex arguments that connect to monitors?
	if ( mutexArgs.empty() ) {
		// If this is the destructor for a monitor it must be mutex.
		if ( isDtor ) {
			// This reflects MutexKeyword::validate, but no error messages.
			const ast::Type * type = decl->type->params.front();

			// If it's a copy, it's not a mutex.
			const ast::ReferenceType * refType = dynamic_cast<const ast::ReferenceType *>( type );
			if ( nullptr == refType ) {
				return decl;
			}

			// If it is not pointing directly to a type, it's not a mutex.
			auto base = refType->base;
			if ( base.as<ast::ReferenceType>() ) return decl;
			if ( base.as<ast::PointerType>() ) return decl;

			// If it is not a struct, it's not a mutex.
			auto baseStruct = base.as<ast::StructInstType>();
			if ( nullptr == baseStruct ) return decl;

			// If it is a monitor, then it is a monitor.
			if ( baseStruct->base->is_monitor() || baseStruct->base->is_thread() ) {
				SemanticError( decl, "destructors for structures declared as \"monitor\" must use mutex parameters " );
			}
		}
		return decl;
	}

	// Monitors can't be constructed with mutual exclusion.
	if ( CodeGen::isConstructor( decl->name ) && is_first_argument_mutex ) {
		SemanticError( decl, "constructors cannot have mutex parameters " );
	}

	// It makes no sense to have multiple mutex parameters for the destructor.
	if ( isDtor && mutexArgs.size() != 1 ) {
		SemanticError( decl, "destructors can only have 1 mutex argument " );
	}

	// Make sure all the mutex arguments are monitors.
	for ( auto arg : mutexArgs ) {
		validate( arg );
	}

	// Check to see if the body needs to be instrument the body.
	const ast::CompoundStmt * body = decl->stmts;
	if ( !body ) return decl;

	// Check to if the required headers have been seen.
	if ( !monitor_decl || !guard_decl || !dtor_guard_decl ) {
		SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor.hfa>." );
	}

	// Instrument the body.
	ast::CompoundStmt * newBody = nullptr;
	if ( isDtor && isThread( mutexArgs.front() ) ) {
		if ( !thread_guard_decl ) {
			SemanticError( decl, "thread destructor requires threads to be in scope, add #include <thread.hfa>." );
		}
		newBody = addThreadDtorStatements( decl, body, mutexArgs );
	} else if ( isDtor ) {
		newBody = addDtorStatements( decl, body, mutexArgs );
	} else {
		newBody = addStatements( decl, body, mutexArgs );
	}
	assert( newBody );
	return ast::mutate_field( decl, &ast::FunctionDecl::stmts, newBody );
}

void MutexKeyword::postvisit( const ast::StructDecl * decl ) {
	if ( !decl->body ) {
		return;
	} else if ( decl->name == "monitor$" ) {
		assert( !monitor_decl );
		monitor_decl = decl;
	} else if ( decl->name == "monitor_guard_t" ) {
		assert( !guard_decl );
		guard_decl = decl;
	} else if ( decl->name == "monitor_dtor_guard_t" ) {
		assert( !dtor_guard_decl );
		dtor_guard_decl = decl;
	} else if ( decl->name == "thread_dtor_guard_t" ) {
		assert( !thread_guard_decl );
		thread_guard_decl = decl;
	} else if ( decl->name == "__mutex_stmt_lock_guard" ) {
		assert( !lock_guard_decl );
		lock_guard_decl = decl;
	}
}

const ast::Stmt * MutexKeyword::postvisit( const ast::MutexStmt * stmt ) {
	if ( !lock_guard_decl ) {
		SemanticError( stmt->location, "mutex stmt requires a header, add #include <mutex_stmt.hfa>." );
	}
	ast::CompoundStmt * body =
			new ast::CompoundStmt( stmt->location, { stmt->stmt } );

	return addStatements( body, stmt->mutexObjs );;
}

std::vector<const ast::DeclWithType *> MutexKeyword::findMutexArgs(
		const ast::FunctionDecl * decl, bool & first ) {
	std::vector<const ast::DeclWithType *> mutexArgs;

	bool once = true;
	for ( auto arg : decl->params ) {
		const ast::Type * type = arg->get_type();
		if ( type->is_mutex() ) {
			if ( once ) first = true;
			mutexArgs.push_back( arg.get() );
		}
		once = false;
	}
	return mutexArgs;
}

void MutexKeyword::validate( const ast::DeclWithType * decl ) {
	const ast::Type * type = decl->get_type();

	// If it's a copy, it's not a mutex.
	const ast::ReferenceType * refType = dynamic_cast<const ast::ReferenceType *>( type );
	if ( nullptr == refType ) {
		SemanticError( decl, "Mutex argument must be of reference type " );
	}

	// If it is not pointing directly to a type, it's not a mutex.
	auto base = refType->base;
	if ( base.as<ast::ReferenceType>() || base.as<ast::PointerType>() ) {
		SemanticError( decl, "Mutex argument have exactly one level of indirection " );
	}

	// If it is not a struct, it's not a mutex.
	auto baseStruct = base.as<ast::StructInstType>();
	if ( nullptr == baseStruct ) return;

	// Make sure that only the outer reference is mutex.
	if ( baseStruct->is_mutex() ) {
		SemanticError( decl, "mutex keyword may only appear once per argument " );
	}
}

ast::CompoundStmt * MutexKeyword::addDtorStatements(
		const ast::FunctionDecl* func, const ast::CompoundStmt * body,
		const std::vector<const ast::DeclWithType *> & args ) {
	ast::Type * argType = ast::shallowCopy( args.front()->get_type() );
	argType->set_mutex( false );

	ast::CompoundStmt * mutBody = ast::mutate( body );

	// Generated code goes near the beginning of body:
	const CodeLocation & location = mutBody->location;

	const ast::ObjectDecl * monitor = new ast::ObjectDecl(
		location,
		"__monitor",
		new ast::PointerType( new ast::StructInstType( monitor_decl ) ),
		new ast::SingleInit(
			location,
			new ast::UntypedExpr(
				location,
				new ast::NameExpr( location, "get_monitor" ),
				{ new ast::CastExpr(
					location,
					new ast::VariableExpr( location, args.front() ),
					argType, ast::ExplicitCast
				) }
			)
		)
	);

	assert( generic_func );

	// In reverse order:
	// monitor_dtor_guard_t __guard = { __monitor, func, false };
	mutBody->push_front(
		new ast::DeclStmt( location, new ast::ObjectDecl(
			location,
			"__guard",
			new ast::StructInstType( dtor_guard_decl ),
			new ast::ListInit(
				location,
				{
					new ast::SingleInit( location,
						new ast::AddressExpr( location,
							new ast::VariableExpr( location, monitor ) ) ),
					new ast::SingleInit( location,
						new ast::CastExpr( location,
							new ast::VariableExpr( location, func ),
							generic_func,
							ast::ExplicitCast ) ),
					new ast::SingleInit( location,
						ast::ConstantExpr::from_bool( location, false ) ),
				},
				{},
				ast::MaybeConstruct
			)
		))
	);

	// monitor$ * __monitor = get_monitor(a);
	mutBody->push_front( new ast::DeclStmt( location, monitor ) );

	return mutBody;
}

ast::CompoundStmt * MutexKeyword::addStatements(
		const ast::FunctionDecl* func, const ast::CompoundStmt * body,
		const std::vector<const ast::DeclWithType * > & args ) {
	ast::CompoundStmt * mutBody = ast::mutate( body );

	// Code is generated near the beginning of the compound statement.
	const CodeLocation & location = mutBody->location;

	// Make pointer to the monitors.
	ast::ObjectDecl * monitors = new ast::ObjectDecl(
		location,
		"__monitors",
		new ast::ArrayType(
			new ast::PointerType(
				new ast::StructInstType( monitor_decl )
			),
			ast::ConstantExpr::from_ulong( location, args.size() ),
			ast::FixedLen,
			ast::DynamicDim
		),
		new ast::ListInit(
			location,
			map_range<std::vector<ast::ptr<ast::Init>>>(
				args,
				[]( const ast::DeclWithType * decl ) {
					return new ast::SingleInit(
						decl->location,
						new ast::UntypedExpr(
							decl->location,
							new ast::NameExpr( decl->location, "get_monitor" ),
							{
								new ast::CastExpr(
									decl->location,
									new ast::VariableExpr( decl->location, decl ),
									decl->get_type(),
									ast::ExplicitCast
								)
							}
						)
					);
				}
			)
		)
	);

	assert( generic_func );

	// In Reverse Order:
	mutBody->push_front(
		new ast::DeclStmt( location, new ast::ObjectDecl(
			location,
			"__guard",
			new ast::StructInstType( guard_decl ),
			new ast::ListInit(
				location,
				{
					new ast::SingleInit( location,
						new ast::VariableExpr( location, monitors ) ),
					new ast::SingleInit( location,
						ast::ConstantExpr::from_ulong( location, args.size() ) ),
					new ast::SingleInit( location, new ast::CastExpr(
						location,
						new ast::VariableExpr( location, func ),
						generic_func,
						ast::ExplicitCast
					) ),
				},
				{},
				ast::MaybeConstruct
			)
		))
	);

	// monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
	mutBody->push_front( new ast::DeclStmt( location, monitors ) );

	return mutBody;
}

// Generates a cast to the void ptr to the appropriate lock type and dereferences it before calling
// lock or unlock on it used to undo the type erasure done by storing all the lock pointers as void.
ast::ExprStmt * MutexKeyword::genVirtLockUnlockExpr( const std::string & fnName, ast::ptr<ast::Expr> expr, const CodeLocation & location, ast::Expr * param ) {
	return new ast::ExprStmt( location,
		new ast::UntypedExpr( location,
			new ast::NameExpr( location, fnName ), {
				ast::UntypedExpr::createDeref(
					location,
					new ast::CastExpr( location,
						param,
						new ast::PointerType( new ast::TypeofType( new ast::UntypedExpr(
							expr->location,
							new ast::NameExpr( expr->location, "__get_mutexstmt_lock_type" ),
							{ expr }
						) ) ),
						ast::GeneratedFlag::ExplicitCast
					)
				)
			}
		)
	);
}

ast::IfStmt * MutexKeyword::genTypeDiscrimLockUnlock( const std::string & fnName, const std::vector<ast::ptr<ast::Expr>> & args, const CodeLocation & location, ast::UntypedExpr * thisParam ) {
	ast::IfStmt * outerLockIf = nullptr;
	ast::IfStmt * lastLockIf = nullptr;

	//adds an if/elif clause for each lock to assign type from void ptr based on ptr address
	for ( long unsigned int i = 0; i < args.size(); i++ ) {

		ast::UntypedExpr * ifCond = new ast::UntypedExpr( location,
			new ast::NameExpr( location, "?==?" ), {
				ast::deepCopy( thisParam ),
				new ast::CastExpr( location, new ast::AddressExpr( location, args.at(i) ), new ast::PointerType( new ast::VoidType() ))
			}
		);

		ast::IfStmt * currLockIf = new ast::IfStmt(
			location,
			ifCond,
			genVirtLockUnlockExpr( fnName, args.at(i), location, ast::deepCopy( thisParam ) )
		);

		if ( i == 0 ) {
			outerLockIf = currLockIf;
		} else {
			// add ifstmt to else of previous stmt
			lastLockIf->else_ = currLockIf;
		}

		lastLockIf = currLockIf;
	}
	return outerLockIf;
}

void flattenTuple( const ast::UntypedTupleExpr * tuple, std::vector<ast::ptr<ast::Expr>> & output ) {
	for ( auto & expr : tuple->exprs ) {
		const ast::UntypedTupleExpr * innerTuple = dynamic_cast<const ast::UntypedTupleExpr *>(expr.get());
		if ( innerTuple ) flattenTuple( innerTuple, output );
		else output.emplace_back( ast::deepCopy( expr ));
	}
}

ast::CompoundStmt * MutexKeyword::addStatements(
		const ast::CompoundStmt * body,
		const std::vector<ast::ptr<ast::Expr>> & args ) {

	// Code is generated near the beginning of the compound statement.
	const CodeLocation & location = body->location;

		// final body to return
	ast::CompoundStmt * newBody = new ast::CompoundStmt( location );

	// std::string lockFnName = mutex_func_namer.newName();
	// std::string unlockFnName = mutex_func_namer.newName();

	// If any arguments to the mutex stmt are tuples, flatten them
	std::vector<ast::ptr<ast::Expr>> flattenedArgs;
	for ( auto & arg : args ) {
		const ast::UntypedTupleExpr * tuple = dynamic_cast<const ast::UntypedTupleExpr *>(args.at(0).get());
		if ( tuple ) flattenTuple( tuple, flattenedArgs );
		else flattenedArgs.emplace_back( ast::deepCopy( arg ));
	}

	// Make pointer to the monitors.
	ast::ObjectDecl * monitors = new ast::ObjectDecl(
		location,
		"__monitors",
		new ast::ArrayType(
			new ast::PointerType(
				new ast::VoidType()
			),
			ast::ConstantExpr::from_ulong( location, flattenedArgs.size() ),
			ast::FixedLen,
			ast::DynamicDim
		),
		new ast::ListInit(
			location,
			map_range<std::vector<ast::ptr<ast::Init>>>(
				flattenedArgs, [](const ast::Expr * expr) {
					return new ast::SingleInit(
						expr->location,
						new ast::UntypedExpr(
							expr->location,
							new ast::NameExpr( expr->location, "__get_mutexstmt_lock_ptr" ),
							{ expr }
						)
					);
				}
			)
		)
	);

	ast::StructInstType * lock_guard_struct =
			new ast::StructInstType( lock_guard_decl );

	// use try stmts to lock and finally to unlock
	ast::TryStmt * outerTry = nullptr;
	ast::TryStmt * currentTry;
	ast::CompoundStmt * lastBody = nullptr;

	// adds a nested try stmt for each lock we are locking
	for ( long unsigned int i = 0; i < flattenedArgs.size(); i++ ) {
		ast::UntypedExpr * innerAccess = new ast::UntypedExpr(
			location,
			new ast::NameExpr( location,"?[?]" ), {
				new ast::NameExpr( location, "__monitors" ),
				ast::ConstantExpr::from_int( location, i )
			}
		);

		// make the try body
		ast::CompoundStmt * currTryBody = new ast::CompoundStmt( location );
		ast::IfStmt * lockCall = genTypeDiscrimLockUnlock( "lock", flattenedArgs, location, innerAccess );
		currTryBody->push_back( lockCall );

		// make the finally stmt
		ast::CompoundStmt * currFinallyBody = new ast::CompoundStmt( location );
		ast::IfStmt * unlockCall = genTypeDiscrimLockUnlock( "unlock", flattenedArgs, location, innerAccess );
		currFinallyBody->push_back( unlockCall );

		// construct the current try
		currentTry = new ast::TryStmt(
			location,
			currTryBody,
			{},
			new ast::FinallyClause( location, currFinallyBody )
		);
		if ( i == 0 ) outerTry = currentTry;
		else {
			// pushback try into the body of the outer try
			lastBody->push_back( currentTry );
		}
		lastBody = currTryBody;
	}

	// push body into innermost try body
	if ( lastBody != nullptr ) {
		lastBody->push_back( body );
		newBody->push_front( outerTry );
	}

	// monitor_guard_t __guard = { __monitors, # };
	newBody->push_front(
		new ast::DeclStmt(
			location,
			new ast::ObjectDecl(
				location,
				"__guard",
				lock_guard_struct,
				new ast::ListInit(
					location,
					{
						new ast::SingleInit(
							location,
							new ast::VariableExpr( location, monitors ) ),
						new ast::SingleInit(
							location,
							ast::ConstantExpr::from_ulong( location, flattenedArgs.size() ) ),
					},
					{},
					ast::MaybeConstruct
				)
			)
		)
	);

	// monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
	newBody->push_front( new ast::DeclStmt( location, monitors ) );

	// // The parameter for both __lock_curr/__unlock_curr routines.
	// ast::ObjectDecl * this_decl = new ast::ObjectDecl(
	// 	location,
	// 	"this",
	// 	new ast::PointerType( new ast::VoidType() ),
	// 	nullptr,
	// 	{},
	// 	ast::Linkage::Cforall
	// );

	// ast::FunctionDecl * lock_decl = new ast::FunctionDecl(
	// 	location,
	// 	lockFnName,
	// 	{ /* forall */ },
	// 	{
	// 		// Copy the declaration of this.
	// 		this_decl,
	// 	},
	// 	{ /* returns */ },
	// 	nullptr,
	// 	0,
	// 	ast::Linkage::Cforall,
	// 	{ /* attributes */ },
	// 	ast::Function::Inline
	// );

	// ast::FunctionDecl * unlock_decl = new ast::FunctionDecl(
	// 	location,
	// 	unlockFnName,
	// 	{ /* forall */ },
	// 	{
	// 		// Copy the declaration of this.
	// 		ast::deepCopy( this_decl ),
	// 	},
	// 	{ /* returns */ },
	// 	nullptr,
	// 	0,
	// 	ast::Linkage::Cforall,
	// 	{ /* attributes */ },
	// 	ast::Function::Inline
	// );

	// ast::IfStmt * outerLockIf = nullptr;
	// ast::IfStmt * outerUnlockIf = nullptr;
	// ast::IfStmt * lastLockIf = nullptr;
	// ast::IfStmt * lastUnlockIf = nullptr;

	// //adds an if/elif clause for each lock to assign type from void ptr based on ptr address
	// for ( long unsigned int i = 0; i < args.size(); i++ ) {
	// 	ast::VariableExpr * thisParam = new ast::VariableExpr( location, InitTweak::getParamThis( lock_decl ) );
	// 	ast::UntypedExpr * ifCond = new ast::UntypedExpr( location,
	// 		new ast::NameExpr( location, "?==?" ), {
	// 			thisParam,
	// 			new ast::CastExpr( location, new ast::AddressExpr( location, args.at(i) ), new ast::PointerType( new ast::VoidType() ))
	// 		}
	// 	);

	// 	ast::IfStmt * currLockIf = new ast::IfStmt(
	// 		location,
	// 		ast::deepCopy( ifCond ),
	// 		genVirtLockUnlockExpr( "lock", args.at(i), location, ast::deepCopy( thisParam ) )
	// 	);

	// 	ast::IfStmt * currUnlockIf = new ast::IfStmt(
	// 		location,
	// 		ifCond,
	// 		genVirtLockUnlockExpr( "unlock", args.at(i), location, ast::deepCopy( thisParam ) )
	// 	);

	// 	if ( i == 0 ) {
	// 		outerLockIf = currLockIf;
	// 		outerUnlockIf = currUnlockIf;
	// 	} else {
	// 		// add ifstmt to else of previous stmt
	// 		lastLockIf->else_ = currLockIf;
	// 		lastUnlockIf->else_ = currUnlockIf;
	// 	}

	// 	lastLockIf = currLockIf;
	// 	lastUnlockIf = currUnlockIf;
	// }

	// // add pointer typing if/elifs to body of routines
	// lock_decl->stmts = new ast::CompoundStmt( location, { outerLockIf } );
	// unlock_decl->stmts = new ast::CompoundStmt( location, { outerUnlockIf } );

	// // add routines to scope
	// declsToAddBefore.push_back( lock_decl );
	// declsToAddBefore.push_back( unlock_decl );

	// newBody->push_front(new ast::DeclStmt( location, lock_decl ));
	// newBody->push_front(new ast::DeclStmt( location, unlock_decl ));

	return newBody;
}

ast::CompoundStmt * MutexKeyword::addThreadDtorStatements(
		const ast::FunctionDecl*, const ast::CompoundStmt * body,
		const std::vector<const ast::DeclWithType * > & args ) {
	assert( args.size() == 1 );
	const ast::DeclWithType * arg = args.front();
	const ast::Type * argType = arg->get_type();
	assert( argType->is_mutex() );

	ast::CompoundStmt * mutBody = ast::mutate( body );

	// The code is generated near the front of the body.
	const CodeLocation & location = mutBody->location;

	// thread_dtor_guard_t __guard = { this, intptr( 0 ) };
	mutBody->push_front( new ast::DeclStmt(
		location,
		new ast::ObjectDecl(
			location,
			"__guard",
			new ast::StructInstType( thread_guard_decl ),
			new ast::ListInit(
				location,
				{
					new ast::SingleInit( location,
						new ast::CastExpr( location,
							new ast::VariableExpr( location, arg ), argType ) ),
					new ast::SingleInit(
						location,
						new ast::UntypedExpr(
							location,
							new ast::NameExpr( location, "intptr" ), {
								ast::ConstantExpr::from_int( location, 0 ),
							}
						) ),
				},
				{},
				ast::MaybeConstruct
			)
		)
	));

	return mutBody;
}

ast::ptr<ast::Type> MutexKeyword::generic_func =
	new ast::FunctionType( ast::FixedArgs );

// --------------------------------------------------------------------------
struct ThreadStarter final {
	void previsit( const ast::StructDecl * decl );
	const ast::FunctionDecl * postvisit( const ast::FunctionDecl * decl );

private:
	bool thread_ctor_seen = false;
	const ast::StructDecl * thread_decl = nullptr;
};

void ThreadStarter::previsit( const ast::StructDecl * decl ) {
	if ( decl->body && decl->name == "thread$" ) {
		assert( !thread_decl );
		thread_decl = decl;
	}
}

const ast::FunctionDecl * ThreadStarter::postvisit( const ast::FunctionDecl * decl ) {
	if ( !CodeGen::isConstructor( decl->name ) ) return decl;

	// Seach for the thread constructor.
	// (Are the "prefixes" of these to blocks the same?)
	const ast::Type * typeof_this = InitTweak::getTypeofThis( decl->type );
	auto ctored_type = dynamic_cast<const ast::StructInstType *>( typeof_this );
	if ( ctored_type && ctored_type->base == thread_decl ) {
		thread_ctor_seen = true;
	}

	// Modify this declaration, the extra checks to see if we will are first.
	const ast::ptr<ast::DeclWithType> & param = decl->params.front();
	auto type = dynamic_cast<const ast::StructInstType *>(
		ast::getPointerBase( param->get_type() ) );
	if ( nullptr == type ) return decl;
	if ( !type->base->is_thread() ) return decl;
	if ( !thread_decl || !thread_ctor_seen ) {
		SemanticError( type->base->location, "thread keyword requires threads to be in scope, add #include <thread.hfa>." );
	}
	const ast::CompoundStmt * stmt = decl->stmts;
	if ( nullptr == stmt ) return decl;

	// Now do the actual modification:
	ast::CompoundStmt * mutStmt = ast::mutate( stmt );
	const CodeLocation & location = mutStmt->location;
	mutStmt->push_back(
		new ast::ExprStmt(
			location,
			new ast::UntypedExpr(
				location,
				new ast::NameExpr( location, "__thrd_start" ),
				{
					new ast::VariableExpr( location, param ),
					new ast::NameExpr( location, "main" ),
				}
			)
		)
	);

	return ast::mutate_field( decl, &ast::FunctionDecl::stmts, mutStmt );
}

} // namespace

// --------------------------------------------------------------------------
// Interface Functions:

void implementKeywords( ast::TranslationUnit & translationUnit ) {
	ast::Pass<ThreadKeyword>::run( translationUnit );
	ast::Pass<CoroutineKeyword>::run( translationUnit );
	ast::Pass<MonitorKeyword>::run( translationUnit );
	ast::Pass<GeneratorKeyword>::run( translationUnit );
	ast::Pass<SuspendKeyword>::run( translationUnit );
}

void implementMutex( ast::TranslationUnit & translationUnit ) {
	ast::Pass<MutexKeyword>::run( translationUnit );
}

void implementThreadStarter( ast::TranslationUnit & translationUnit ) {
	ast::Pass<ThreadStarter>::run( translationUnit );
}

}

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //