Changeset 19e567dd

Timestamp:

May 21, 2019, 12:48:18 PM (6 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

51ff278, 5b35c21

Parents:

292642a

Message:

expression conversion: first few cases and base members, both directions

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 {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new ApplicationExpr(
+                                get<Expression>().accept1(node->func),
+                                get<Expression>().acceptL(node->args)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedExpr(
+                                get<Expression>().accept1(node->func),
+                                get<Expression>().acceptL(node->args)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::NameExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new NameExpr(
+                                node->name
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
@@ -1184 +1256 @@
                                       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
+
+                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);
+                        }
+                }
         }
 
@@ -1206 +1296 @@
         }
 
-        virtual void visit( ApplicationExpr * ) override final {
-                // TODO
-        }
-
-        virtual void visit( UntypedExpr * ) override final {
-                // TODO
+        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)
+                        )
+                );
         }
 
@@ -1223 +1325 @@
         }
 
-        virtual void visit( CastExpr * ) override final {
-                // TODO ... (rest)
+        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
+                        )
+                );
         }
 

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);
                 }
 
@@ -114 +123 @@
                         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);
                 }
         };