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

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 16:01:00 2019
-// Update Count     : 4
+// Last Modified On : Fri May 17 12:13:00 2019
+// Update Count     : 3
 //
 
 #include "Convert.hpp"
-
-#include "AST/Pass.hpp"
 
 #include "AST/Attribute.hpp"
@@ -23 +21 @@
 #include "AST/Init.hpp"
 #include "AST/Stmt.hpp"
-
+#include "AST/TypeSubstitution.hpp"
 
 #include "SynTree/Attribute.h"
 #include "SynTree/Declaration.h"
+#include "SynTree/TypeSubstitution.h"
 
 //================================================================================================
@@ -42 +41 @@
 //================================================================================================
 class ConverterNewToOld : public ast::Visitor {
+public:
+        template<typename T>
+        T * get() {
+                T * ret = strict_dynamic_cast< T * >( node );
+                node = nullptr;
+                return ret;
+        }
+
+private:
         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:
-        Declaration * decl( const ast::Decl * declNode ) {
-                return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
-        }
-
-private:
+        // All the visit functions:
+
         const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
                 (void)node;
@@ -145 +105 @@
 
         const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
-                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
-                auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
-                auto stmt = new DirectiveStmt( node->directive );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::IfStmt * node ) override final {
-                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;
+                (void)node;
+                return nullptr;
+        }
+
+        const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
+                (void)node;
+                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 {
-                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;
+                (void)node;
                 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 {
-                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 {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
-                auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::TryStmt * node ) override final {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
-                auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WithStmt * node ) override final {
-                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;
+                (void)node;
                 return nullptr;
         }
 
         const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
-                auto stmt = new NullStmt();
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
-                auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                (void)node;
                 return nullptr;
         }
@@ -723 +514 @@
         std::list< Declaration * > decls;
         for(auto d : translationUnit) {
-                decls.emplace_back( c.decl( d ) );
+                d->accept( c );
+                decls.emplace_back( c.get<Declaration>() );
                 delete d;
         }
@@ -1172 +964 @@
         }
 
+        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 {
-
-        }
-
-        virtual void visit( NameExpr * ) 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( CastExpr * ) override final {
-
+                // TODO ... (rest)
         }