Changes in src/AST/Convert.cpp [19e567dd:675d816]

File:

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

src/AST/Convert.cpp

@@ -16 +16 @@
 #include "Convert.hpp"
 
+#include "AST/Pass.hpp"
+
 #include "AST/Attribute.hpp"
 #include "AST/Decl.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"
 
 //================================================================================================
@@ -412 +413 @@
         }
 
-        TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
-
-                TypeSubstitution *rslt = new TypeSubstitution();
-
-                for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
-                        rslt->add( src_i->first,
-                                   get<Type>().accept1(src_i->second) );
-                }
-
-                for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
-                        rslt->addVar( src_i->first,
-                                      get<Expression>().accept1(src_i->second) );
-                }
-
-                return rslt;
-        }
-
-        void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
-                                                   std::vector<UniqueId>         &tgtResnSlots,
-                                                   const ast::Expr::InferUnion   &srcInferred ) {
-
-                assert( tgtInferParams.empty() );
-                assert( tgtResnSlots.empty() );
-
-                if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
-                        const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
-                        for (auto srcParam : srcParams) {
-                                tgtInferParams[srcParam.first] = ParamEntry(
-                                        srcParam.second.decl,
-                                        get<Type>().accept1(srcParam.second.actualType),
-                                        get<Type>().accept1(srcParam.second.formalType),
-                                        get<Expression>().accept1(srcParam.second.expr)
-                                );
-                        }
-                } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
-                        const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
-                        for (auto srcSlot : srcSlots) {
-                                tgtResnSlots.push_back(srcSlot);
-                        }
-                }
-        }
-
-        Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
-
-                tgt->location = src->location;
-
-                tgt->result = get<Type>().accept1(src->result);
-                tgt->env    = convertTypeSubstitution(src->env);
-
-                tgt->extension = src->extension;
-                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
-
-                return tgt;
-        }
-
         const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
-                auto expr = visitBaseExpr( node,
-                        new ApplicationExpr(
-                                get<Expression>().accept1(node->func),
-                                get<Expression>().acceptL(node->args)
-                        )
-                );
-                this->node = expr;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
-                auto expr = visitBaseExpr( node,
-                        new UntypedExpr(
-                                get<Expression>().accept1(node->func),
-                                get<Expression>().acceptL(node->args)
-                        )
-                );
-                this->node = expr;
+                (void)node;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::NameExpr * node ) override final {
-                auto expr = visitBaseExpr( node,
-                        new NameExpr(
-                                node->name
-                        )
-                );
-                this->node = expr;
+                (void)node;
                 return nullptr;
         }
@@ -1243 +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) );
-                }
-
-                return rslt;
-        }
-
-        void convertInferUnion(ast::Expr::InferUnion               &newInferred, 
-                                                   const std::map<UniqueId,ParamEntry> &oldInferParams,
-                                                   const std::vector<UniqueId>         &oldResnSlots) {
-
-                assert( oldInferParams.empty() || oldResnSlots.empty() );
-                assert( newInferred.mode == ast::Expr::InferUnion::Empty );
-
-                if ( !oldInferParams.empty() ) {
-                        ast::InferredParams &tgt = newInferred.inferParams();
-                        for (auto old : oldInferParams) {
-                                tgt[old.first] = ast::ParamEntry(
-                                        old.second.decl,
-                                        getAccept1<ast::Type>(old.second.actualType),
-                                        getAccept1<ast::Type>(old.second.formalType),
-                                        getAccept1<ast::Expr>(old.second.expr)
-                                );
-                        }
-                } else if ( !oldResnSlots.empty() ) {
-                        ast::ResnSlots &tgt = newInferred.resnSlots();
-                        for (auto old : oldResnSlots) {
-                                tgt.push_back(old);
-                        }
-                }
-        }
-
-        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 * old ) override final {
-                this->node = visitBaseExpr( old,
-                        new ast::ApplicationExpr(
-                                old->location,
-                                GET_ACCEPT_1(function, Expr),
-                                GET_ACCEPT_V(args, Expr)
-                        )
-                );
-        }
-
-        virtual void visit( UntypedExpr * old ) override final {
-                this->node = visitBaseExpr( old,
-                        new ast::UntypedExpr(
-                                old->location,
-                                GET_ACCEPT_1(function, Expr),
-                                GET_ACCEPT_V(args, Expr)
-                        )
-                );
-        }
-
-        virtual void visit( NameExpr * old ) override final {
-                this->node = visitBaseExpr( old,
-                        new ast::NameExpr(
-                                old->location,
-                                old->get_name()
-                        )
-                );
-        }
-
-        virtual void visit( CastExpr * old ) override final {
-                this->node = visitBaseExpr( old,
-                        new ast::CastExpr(
-                                old->location,
-                                nullptr, // cast's "to" type is expr's result type; converted in visitBaseExpr
-                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
-                        )
-                );
+        virtual void visit( ApplicationExpr * ) override final {
+
+        }
+
+        virtual void visit( UntypedExpr * ) override final {
+
+        }
+
+        virtual void visit( NameExpr * ) override final {
+
+        }
+
+        virtual void visit( CastExpr * ) override final {
+
         }