Changeset 51ff278 for src/AST/Convert.cpp

Timestamp:

May 21, 2019, 2:28:00 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

e0016a5

Parents:

17a0228a (diff), 19e567dd (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/AST/Convert.cpp (modified) (4 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
+                        )
+                );
         }