Changes in src/AST/Convert.cpp [172d9342:675d816]

File:

• src/AST/Convert.cpp (modified) (6 diffs)

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 12:13:00 2019
-// Update Count     : 3
+// Last Modified On : Fri May 17 16:01:00 2019
+// Update Count     : 4
 //
 
 #include "Convert.hpp"
+
+#include "AST/Pass.hpp"
 
 #include "AST/Attribute.hpp"
@@ -21 +23 @@
 #include "AST/Init.hpp"
 #include "AST/Stmt.hpp"
-#include "AST/TypeSubstitution.hpp"
+
 
 #include "SynTree/Attribute.h"
 #include "SynTree/Declaration.h"
-#include "SynTree/TypeSubstitution.h"
 
 //================================================================================================
@@ -41 +42 @@
 //================================================================================================
 class ConverterNewToOld : public ast::Visitor {
+        BaseSyntaxNode * node = nullptr;
+
+        template<typename T>
+        struct Getter {
+                ConverterNewToOld & visitor;
+
+                template<typename U>
+                T * accept1( const ast::ptr<U> & ptr ) {
+                        ptr->accept( visitor );
+                        T * ret = strict_dynamic_cast< T * >( visitor.node );
+                        visitor.node = nullptr;
+                        return ret;
+                }
+
+                template<typename U>
+                std::list< T * > acceptL( const U & container ) {
+                        std::list< T * > ret;
+                        for (auto ptr : container ) {
+                                ret.emplace_back( accept1( ptr ) );
+                        }
+                        return ret;
+                }
+        };
+
+    template<typename T>
+    Getter<T> get() {
+        return Getter<T>{ *this };
+    }
+
+        Label makeLabel(Statement * labelled, const ast::Label& label) {
+                return Label(
+                        label.name,
+                        labelled,
+                        get<Attribute>().acceptL(label.attributes)
+                );
+        }
+
+        template<template <class...> class C>
+        std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
+                std::list<Label> ret;
+                for (auto label : labels) {
+                        ret.push_back( makeLabel(labelled, label) );
+                }
+                return ret;
+        }
+
 public:
-        template<typename T>
-        T * get() {
-                T * ret = strict_dynamic_cast< T * >( node );
-                node = nullptr;
-                return ret;
+        Declaration * decl( const ast::Decl * declNode ) {
+                return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
         }
 
 private:
-        BaseSyntaxNode * node = nullptr;
-
-        // All the visit functions:
-
         const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
                 (void)node;
@@ -105 +145 @@
 
         const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
-                (void)node;
+                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
-                (void)node;
+                auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
-                (void)node;
+                auto stmt = new AsmStmt(
+                        node->isVolatile,
+                        get<Expression>().accept1( node->instruction ),
+                        get<Expression>().acceptL( node->output ),
+                        get<Expression>().acceptL( node->input ),
+                        get<ConstantExpr>().acceptL( node->clobber ),
+                        makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
-                (void)node;
+                auto stmt = new DirectiveStmt( node->directive );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::IfStmt * node ) override final {
-                (void)node;
+                auto stmt = new IfStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().accept1( node->thenPart ),
+                        get<Statement>().accept1( node->elsePart ),
+                        get<Statement>().acceptL( node->inits )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
+                return nullptr;
+        }
+
+        const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
+                auto stmt = new SwitchStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().acceptL( node->stmts )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
+                return nullptr;
+        }
+
+        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
+                auto stmt = new CaseStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().acceptL( node->stmts ),
+                        node->isDefault()
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
-                (void)node;
+                auto inits = get<Statement>().acceptL( node->inits );
+                auto stmt = new WhileStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().accept1( node->body ),
+                        inits,
+                        node->isDoWhile
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ForStmt * node ) override final {
-                (void)node;
-                return nullptr;
-        }
-
-        const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
-                (void)node;
-                return nullptr;
-        }
-
-        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
-                (void)node;
+                auto stmt = new ForStmt(
+                        get<Statement>().acceptL( node->inits ),
+                        get<Expression>().accept1( node->cond ),
+                        get<Expression>().accept1( node->inc ),
+                        get<Statement>().accept1( node->body )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
-                (void)node;
+                BranchStmt * stmt;
+                if (node->computedTarget) {
+                        stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
+                                BranchStmt::Goto );
+                } else {
+                        BranchStmt::Type type;
+                        switch (node->kind) {
+                        #define CASE(n) \
+                        case ast::BranchStmt::n: \
+                                type = BranchStmt::n; \
+                                break
+                        CASE(Goto);
+                        CASE(Break);
+                        CASE(Continue);
+                        CASE(FallThrough);
+                        CASE(FallThroughDefault);
+                        #undef CASE
+                        default:
+                                assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
+                        }
+
+                        // The labels here are also weird.
+                        stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
+                        stmt->target = makeLabel( stmt, node->target );
+                }
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
-                (void)node;
+                auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
-                (void)node;
+                ThrowStmt::Kind kind;
+                switch (node->kind) {
+                case ast::ThrowStmt::Terminate:
+                        kind = ThrowStmt::Terminate;
+                        break;
+                case ast::ThrowStmt::Resume:
+                        kind = ThrowStmt::Resume;
+                        break;
+                default:
+                        assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
+                }
+                auto stmt = new ThrowStmt(
+                        kind,
+                        get<Expression>().accept1( node->expr ),
+                        get<Expression>().accept1( node->target )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::TryStmt * node ) override final {
-                (void)node;
+                auto handlers = get<CatchStmt>().acceptL( node->handlers );
+                auto stmt = new TryStmt(
+                        get<CompoundStmt>().accept1( node->body ),
+                        handlers,
+                        get<FinallyStmt>().accept1( node->finally )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
-                (void)node;
+                CatchStmt::Kind kind;
+                switch (node->kind) {
+                case ast::CatchStmt::Terminate:
+                        kind = CatchStmt::Terminate;
+                        break;
+                case ast::CatchStmt::Resume:
+                        kind = CatchStmt::Resume;
+                        break;
+                default:
+                        assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
+                }
+                auto stmt = new CatchStmt(
+                        kind,
+                        get<Declaration>().accept1( node->decl ),
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().accept1( node->body )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
-                (void)node;
+                auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
-                (void)node;
+                auto stmt = new WaitForStmt;
+                stmt->clauses.reserve( node->clauses.size() );
+                for ( auto clause : node->clauses ) {
+                        stmt->clauses.push_back({{
+                                        get<Expression>().accept1( clause.target.function ),
+                                        get<Expression>().acceptL( clause.target.arguments ),
+                                },
+                                get<Statement>().accept1( clause.stmt ),
+                                get<Expression>().accept1( clause.cond ),
+                        });
+                }
+                stmt->timeout = {
+                        get<Expression>().accept1( node->timeout.time ),
+                        get<Statement>().accept1( node->timeout.stmt ),
+                        get<Expression>().accept1( node->timeout.cond ),
+                };
+                stmt->orelse = {
+                        get<Statement>().accept1( node->orElse.stmt ),
+                        get<Expression>().accept1( node->orElse.cond ),
+                };
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WithStmt * node ) override final {
-                (void)node;
+                auto stmt = new WithStmt(
+                        get<Expression>().acceptL( node->exprs ),
+                        get<Statement>().accept1( node->stmt )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
-                (void)node;
+                auto stmt = new NullStmt();
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
-                (void)node;
+                auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
@@ -514 +723 @@
         std::list< Declaration * > decls;
         for(auto d : translationUnit) {
-                d->accept( c );
-                decls.emplace_back( c.get<Declaration>() );
+                decls.emplace_back( c.decl( d ) );
                 delete d;
         }
@@ -964 +1172 @@
         }
 
-        ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
-
-                ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
-
-                for (decltype(old->begin()) old_i = old->begin(); old_i != old->end(); old_i++) {
-                        rslt->add( old_i->first,
-                                   getAccept1<ast::Type>(old_i->second) );
-                }
-
-                for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
-                        rslt->addVar( old_i->first,
-                                      getAccept1<ast::Expr>(old_i->second) );
-                }
-        }
-
-        void convertInferUnion(ast::Expr::InferUnion &nwInferred, InferredParams oldInferParams, const std::vector<UniqueId> &oldResnSlots) {
-                
-                (void) nwInferred;
-                (void) oldInferParams;
-                (void) oldResnSlots;
-                
-                // TODO
-        }
-
-        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
-
-                nw->result = GET_ACCEPT_1(result, Type);
-                nw->env    = convertTypeSubstitution(old->env);
-
-                nw->extension = old->extension;
-                convertInferUnion(nw->inferred, old->inferParams, old->resnSlots);
-
-                return nw;
-        }
-
         virtual void visit( ApplicationExpr * ) override final {
-                // TODO
+
         }
 
         virtual void visit( UntypedExpr * ) override final {
-                // TODO
-        }
-
-        virtual void visit( NameExpr * old ) override final {
-                this->node = visitBaseExpr( old,
-                        new ast::NameExpr(
-                                old->location,
-                                old->get_name()
-                        )
-                );
+
+        }
+
+        virtual void visit( NameExpr * ) override final {
+
         }
 
         virtual void visit( CastExpr * ) override final {
-                // TODO ... (rest)
+
         }