Changeset 4f6dda0 for src/Concurrency/KeywordsNew.cpp

Timestamp:

Mar 11, 2022, 11:08:19 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

630c4bb

Parents:

b053083

Message:

Converted Implement Concurrent Keywords to the new AST. Includes updates to various helpers, including the virtual table and a lot of examine helpers.

File:

• src/Concurrency/KeywordsNew.cpp (modified) (5 diffs)

src/Concurrency/KeywordsNew.cpp

@@ -10 +10 @@
 // Created On       : Tue Nov 16  9:53:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Dec  1 11:24:00 2021
-// Update Count     : 1
+// Last Modified On : Fri Mar 11 10:40:00 2022
+// Update Count     : 2
 //
 
@@ -18 +18 @@
 #include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
+#include "AST/Expr.hpp"
 #include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
+#include "AST/DeclReplacer.hpp"
 #include "AST/TranslationUnit.hpp"
 #include "CodeGen/OperatorTable.h"
+#include "Common/Examine.h"
 #include "Common/utility.h"
+#include "ControlStruct/LabelGeneratorNew.hpp"
 #include "InitTweak/InitTweak.h"
+#include "Virtual/Tables.h"
 
 namespace Concurrency {
@@ -29 +34 @@
 namespace {
 
-inline static bool isThread( const ast::DeclWithType * decl ) {
+// --------------------------------------------------------------------------
+// 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->name, 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->name, typeDecl ) ) );
+                typeParamInst->params.push_back(
+                        new ast::TypeExpr( location,
+                                new ast::TypeInstType( typeDecl->name, typeDecl ) ) );
+        }
+
+        return mutFunc;
+}
+
+// --------------------------------------------------------------------------
+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 thread type declarations:
+//
+// thread Mythread {                         struct MyThread {
+//  int data;                                  int data;
+//  a_struct_t more_data;                      a_struct_t more_data;
+//                                =>             thread$ __thrd_d;
+// };                                        };
+//                                           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() {}
+};
+
+// Handles coroutine type declarations:
+//
+// coroutine MyCoroutine {                   struct MyCoroutine {
+//  int data;                                  int data;
+//  a_struct_t more_data;                      a_struct_t more_data;
+//                                =>             coroutine$ __cor_d;
+// };                                        };
+//                                           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 {
+//  int data;                                  int data;
+//  a_struct_t more_data;                      a_struct_t more_data;
+//                                =>             monitor$ __mon_d;
+// };                                        };
+//                                           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 generator type declarations:
+//
+// generator MyGenerator {                   struct MyGenerator {
+//  int data;                                  int data;
+//  a_struct_t more_data;                      a_struct_t more_data;
+//                                =>             int __generator_state;
+// };                                        };
+//
+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() {}
+};
+
+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 ) ),
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                )
+        );
+        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 ) ),
+                nullptr,
+                ast::Storage::Classes(),
+                ast::Linkage::Cforall
+        );
+
+        ast::ObjectDecl * ret_decl = new ast::ObjectDecl(
+                location,
+                "ret",
+                new ast::PointerType( new ast::StructInstType( type_decl ) ),
+                nullptr,
+                ast::Storage::Classes(),
+                ast::Linkage::Cforall
+        );
+
+        ast::FunctionDecl * get_decl = new ast::FunctionDecl(
+                location,
+                getter_name,
+                {}, // forall
+                { 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 ),
+                nullptr,
+                ast::Storage::Classes(),
+                ast::Linkage::Cforall
+        );
+
+        auto mutDecl = ast::mutate( decl );
+        mutDecl->members.push_back( field );
+
+        return {mutDecl, field};
+}
+
+void ConcurrentSueKeyword::addGetRoutines(
+                const ast::ObjectDecl * field, const ast::FunctionDecl * forward ) {
+        // Say it is generated at the "same" places as the forward declaration.
+        const CodeLocation & location = forward->location;
+
+        const ast::DeclWithType * param = forward->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
+                                )
+                        )
+                )
+        );
+
+        ast::FunctionDecl * decl = ast::deepCopy( forward );
+        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 ) ),
+                nullptr,
+                ast::Storage::Classes(),
+                ast::Linkage::Cforall
+        );
+
+        ast::FunctionDecl * lock_decl = new ast::FunctionDecl(
+                location,
+                "lock",
+                { /* forall */ },
+                {
+                        // 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",
+                { /* forall */ },
+                {
+                        // 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->type ) {
+        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>\n" );
+        }
+        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 ) )
+        );
 }
 
@@ -251 +1088 @@
                                 {
                                         new ast::SingleInit( location,
-                                                new ast::AddressExpr(
+                                                new ast::AddressExpr( location,
                                                         new ast::VariableExpr( location, monitor ) ) ),
                                         new ast::SingleInit( location,
@@ -564 +1401 @@
 
 // --------------------------------------------------------------------------
+// Interface Functions:
 
 void implementKeywords( ast::TranslationUnit & translationUnit ) {
-        (void)translationUnit;
-        assertf(false, "Apply Keywords not implemented." );
+        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 );
 }