Changes in src/AST/Convert.cpp [9e7236f4:7edd5c1]

File:

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

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Mar 16 15:01:00 2022
-// Update Count     : 42
+// Last Modified On : Wed Apr 20 13:58:00 2022
+// Update Count     : 43
 //
 
@@ -93 +93 @@
         };
 
-    template<typename T>
-    Getter<T> get() {
-        return Getter<T>{ *this };
-    }
+        template<typename T>
+        Getter<T> get() {
+                return Getter<T>{ *this };
+        }
 
         Label makeLabel(Statement * labelled, const ast::Label& label) {
@@ -562 +562 @@
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
-                                        get<Expression>().accept1( clause.target.func ),
-                                        get<Expression>().acceptL( clause.target.args ),
+                                        get<Expression>().accept1( clause->target_func ),
+                                        get<Expression>().acceptL( clause->target_args ),
                                 },
-                                get<Statement>().accept1( clause.stmt ),
-                                get<Expression>().accept1( clause.cond ),
+                                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 ),
+                        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 ),
+                        get<Statement>().accept1( node->else_stmt ),
+                        get<Expression>().accept1( node->else_cond ),
                 };
                 return stmtPostamble( stmt, node );
+        }
+
+        const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
+                // There is no old-AST WaitForClause, so this should never be called.
+                assert( !node );
+                return nullptr;
         }
 
@@ -1645 +1651 @@
                         // GET_ACCEPT_1(type, FunctionType),
                         std::move(forall),
+                        std::move(assertions),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1658 +1665 @@
                 cache.emplace( old, decl );
 
-                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
@@ -2096 +2102 @@
                 stmt->clauses.reserve( old->clauses.size() );
                 for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
-                        stmt->clauses.push_back({
-                                ast::WaitForStmt::Target{
-                                        GET_ACCEPT_1(clauses[i].target.function, Expr),
-                                        GET_ACCEPT_V(clauses[i].target.arguments, Expr)
-                                },
-                                GET_ACCEPT_1(clauses[i].statement, Stmt),
-                                GET_ACCEPT_1(clauses[i].condition, Expr)
-                        });
-                }
-                stmt->timeout = {
-                        GET_ACCEPT_1(timeout.time, Expr),
-                        GET_ACCEPT_1(timeout.statement, Stmt),
-                        GET_ACCEPT_1(timeout.condition, Expr),
-                };
-                stmt->orElse = {
-                        GET_ACCEPT_1(orelse.statement, Stmt),
-                        GET_ACCEPT_1(orelse.condition, Expr),
-                };
+                        auto clause = new ast::WaitForClause( old->location );
+
+                        clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
+                        clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
+                        clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
+                        clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+
+                        stmt->clauses.push_back( clause );
+                }
+                stmt->timeout_time = GET_ACCEPT_1(timeout.time, Expr);
+                stmt->timeout_stmt = GET_ACCEPT_1(timeout.statement, Stmt);
+                stmt->timeout_cond = GET_ACCEPT_1(timeout.condition, Expr);
+                stmt->else_stmt = GET_ACCEPT_1(orelse.statement, Stmt);
+                stmt->else_cond = GET_ACCEPT_1(orelse.condition, Expr);
 
                 this->node = stmt;
@@ -2727 +2729 @@
                         ty->forall.emplace_back(new ast::TypeInstType(param));
                         for (auto asst : param->assertions) {
-                                ty->assertions.emplace_back(new ast::VariableExpr({}, asst));
+                                ty->assertions.emplace_back(
+                                        new ast::VariableExpr(param->location, asst));
                         }
                 }