Changes in src/ResolvExpr/Resolver.cc [9e23b446:9e7236f4]

File:

• src/ResolvExpr/Resolver.cc (modified) (8 diffs)

src/ResolvExpr/Resolver.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 20 10:41:00 2022
-// Update Count     : 248
+// Last Modified On : Fri Mar 18 10:41:00 2022
+// Update Count     : 247
 //
 
@@ -1555 +1555 @@
                 if ( type->dimension ) {
                         ast::ptr< ast::Type > sizeType = context.global.sizeType;
-                        ast::ptr< ast::Expr > dimension = findSingleExpression( type->dimension, sizeType, context );
-                        assertf(dimension->env->empty(), "array dimension expr has nonempty env");
-                        dimension.get_and_mutate()->env = nullptr;
                         ast::mutate_field(
                                 type, &PtrType::dimension,
-                                dimension);
+                                findSingleExpression( type->dimension, sizeType, context ) );
                 }
                 return type;
@@ -1725 +1722 @@
                 // Resolve all clauses first
                 for ( unsigned i = 0; i < stmt->clauses.size(); ++i ) {
-                        const ast::WaitForClause & clause = *stmt->clauses[i];
+                        const ast::WaitForStmt::Clause & clause = stmt->clauses[i];
 
                         ast::TypeEnvironment env;
@@ -1731 +1728 @@
 
                         // Find all candidates for a function in canonical form
-                        funcFinder.find( clause.target_func, ResolvMode::withAdjustment() );
+                        funcFinder.find( clause.target.func, ResolvMode::withAdjustment() );
 
                         if ( funcFinder.candidates.empty() ) {
                                 stringstream ss;
                                 ss << "Use of undeclared indentifier '";
-                                ss << clause.target_func.strict_as< ast::NameExpr >()->name;
+                                ss << clause.target.func.strict_as< ast::NameExpr >()->name;
                                 ss << "' in call to waitfor";
                                 SemanticError( stmt->location, ss.str() );
                         }
 
-                        if ( clause.target_args.empty() ) {
+                        if ( clause.target.args.empty() ) {
                                 SemanticError( stmt->location,
                                         "Waitfor clause must have at least one mutex parameter");
@@ -1748 +1745 @@
                         // Find all alternatives for all arguments in canonical form
                         std::vector< CandidateFinder > argFinders =
-                                funcFinder.findSubExprs( clause.target_args );
+                                funcFinder.findSubExprs( clause.target.args );
 
                         // List all combinations of arguments
@@ -1921 +1918 @@
 
                         // build new clause
-                        auto clause2 = new ast::WaitForClause( clause.location );
-
-                        clause2->target_func = funcCandidates.front()->expr;
-
-                        clause2->target_args.reserve( clause.target_args.size() );
+                        ast::WaitForStmt::Clause clause2;
+
+                        clause2.target.func = funcCandidates.front()->expr;
+
+                        clause2.target.args.reserve( clause.target.args.size() );
                         const ast::StructDecl * decl_monitor = symtab.lookupStruct( "monitor$" );
                         for ( auto arg : argsCandidates.front() ) {
@@ -1942 +1939 @@
                                 );
 
-                                clause2->target_args.emplace_back( findSingleExpression( init, context ) );
+                                clause2.target.args.emplace_back( findSingleExpression( init, context ) );
                         }
 
                         // Resolve the conditions as if it were an IfStmt, statements normally
-                        clause2->cond = findSingleExpression( clause.cond, context );
-                        clause2->stmt = clause.stmt->accept( *visitor );
+                        clause2.cond = findSingleExpression( clause.cond, context );
+                        clause2.stmt = clause.stmt->accept( *visitor );
 
                         // set results into stmt
                         auto n = mutate( stmt );
-                        n->clauses[i] = clause2;
+                        n->clauses[i] = std::move( clause2 );
                         stmt = n;
                 }
 
-                if ( stmt->timeout_stmt ) {
+                if ( stmt->timeout.stmt ) {
                         // resolve the timeout as a size_t, the conditions like IfStmt, and stmts normally
+                        ast::WaitForStmt::Timeout timeout2;
+
                         ast::ptr< ast::Type > target =
                                 new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
-                        auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
-                        auto timeout_cond = findSingleExpression( stmt->timeout_cond, context );
-                        auto timeout_stmt = stmt->timeout_stmt->accept( *visitor );
+                        timeout2.time = findSingleExpression( stmt->timeout.time, target, context );
+                        timeout2.cond = findSingleExpression( stmt->timeout.cond, context );
+                        timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
 
                         // set results into stmt
                         auto n = mutate( stmt );
-                        n->timeout_time = std::move( timeout_time );
-                        n->timeout_cond = std::move( timeout_cond );
-                        n->timeout_stmt = std::move( timeout_stmt );
+                        n->timeout = std::move( timeout2 );
                         stmt = n;
                 }
 
-                if ( stmt->else_stmt ) {
+                if ( stmt->orElse.stmt ) {
                         // resolve the condition like IfStmt, stmts normally
-                        auto else_cond = findSingleExpression( stmt->else_cond, context );
-                        auto else_stmt = stmt->else_stmt->accept( *visitor );
+                        ast::WaitForStmt::OrElse orElse2;
+
+                        orElse2.cond = findSingleExpression( stmt->orElse.cond, context );
+                        orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
 
                         // set results into stmt
                         auto n = mutate( stmt );
-                        n->else_cond = std::move( else_cond );
-                        n->else_stmt = std::move( else_stmt );
+                        n->orElse = std::move( orElse2 );
                         stmt = n;
                 }
@@ -2011 +2009 @@
                                 tmp->accept( *visitor );
                         }
-                        else if (expr->env && expr->env->empty()) {
-                                expr = ast::mutate_field(expr.get(), &ast::Expr::env, nullptr);
-                        }
                 }
         }