Changes in / [5b35c21:e63326b]

Location:

src/AST

Files:

• Convert.cpp (modified) (4 diffs)
• Expr.hpp (modified) (2 diffs)

src/AST/Convert.cpp

@@ -412 +412 @@
         }
 
-        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;
         }
@@ -1256 +1184 @@
                                       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);
-                        }
-                }
+        }
+
+        void convertInferUnion(ast::Expr::InferUnion &nwInferred, InferredParams oldInferParams, const std::vector<UniqueId> &oldResnSlots) {
+                
+                (void) nwInferred;
+                (void) oldInferParams;
+                (void) oldResnSlots;
+                
+                // TODO
         }
 
@@ -1296 +1206 @@
         }
 
-        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( ApplicationExpr * ) override final {
+                // TODO
+        }
+
+        virtual void visit( UntypedExpr * ) override final {
+                // TODO
         }
 
@@ -1325 +1223 @@
         }
 
-        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( CastExpr * ) override final {
+                // TODO ... (rest)
         }
 

src/AST/Expr.hpp

@@ -106 +106 @@
                         case Params: assert(!"Cannot return to resnSlots from Params");
                         }
-                        return *((ResnSlots*)nullptr);
-                }
-
-                const ResnSlots& resnSlotsConst() const {
-                        if (mode == Slots) {
-                                return data.resnSlots;
-                        }
-                        assert(!"Mode was not already resnSlots");
-                        return *((ResnSlots*)nullptr);
                 }
 
@@ -123 +114 @@
                         case Params: return data.inferParams;
                         }
-                        return *((InferredParams*)nullptr);
-                }
-
-                const InferredParams& inferParamsConst() const {
-                        if (mode == Params) {
-                                return data.inferParams;
-                        }
-                        assert(!"Mode was not already Params");
-                        return *((InferredParams*)nullptr);
                 }
         };