Changeset 3bc69f2 for src/ResolvExpr

Timestamp:

Mar 18, 2022, 10:53:38 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

22226e4

Parents:

f7496c5

Message:

May have fixed the build failure, but I'm still not sure why WaitForStmt? seemed to trigger it.

File:

• src/ResolvExpr/Resolver.cc (modified) (30 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 Mar 16 16:07:00 2022
-// Update Count     : 246
+// Last Modified On : Fri Mar 18 10:41:00 2022
+// Update Count     : 247
 //
 
@@ -1245 +1245 @@
         : public ast::WithSymbolTable, public ast::WithGuards,
           public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
-          public ast::WithStmtsToAdd<>, public ast::WithConstTranslationUnit {
+          public ast::WithStmtsToAdd<> {
 
                 ast::ptr< ast::Type > functionReturn = nullptr;
@@ -1251 +1251 @@
                 // for work previously in GenInit
                 static InitTweak::ManagedTypes_new managedTypes;
+                ResolveContext context;
 
                 bool inEnumDecl = false;
-
-                ResolveContext getContext() const {
-                        return ResolveContext{ symtab, transUnit().global };
-                }
 
         public:
                 static size_t traceId;
-                Resolver_new() = default;
-                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
+                Resolver_new( const ast::TranslationGlobal & global ) :
+                        context{ symtab, global } {}
+                Resolver_new( const ResolveContext & context ) :
+                        ast::WithSymbolTable{ context.symtab },
+                        context{ symtab, context.global } {}
 
                 const ast::FunctionDecl * previsit( const ast::FunctionDecl * );
@@ -1278 +1278 @@
                 const ast::AsmStmt *         previsit( const ast::AsmStmt * );
                 const ast::IfStmt *          previsit( const ast::IfStmt * );
-                const ast::WhileDoStmt *       previsit( const ast::WhileDoStmt * );
+                const ast::WhileDoStmt *     previsit( const ast::WhileDoStmt * );
                 const ast::ForStmt *         previsit( const ast::ForStmt * );
                 const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
@@ -1305 +1305 @@
 
         void resolve( ast::TranslationUnit& translationUnit ) {
-                ast::Pass< Resolver_new >::run( translationUnit );
+                ast::Pass< Resolver_new >::run( translationUnit, translationUnit.global );
         }
 
@@ -1312 +1312 @@
         ) {
                 assert( ctorInit );
-                ast::Pass< Resolver_new > resolver{ context.symtab };
-                ast::TranslationUnit transUnit;
-                transUnit.global = context.global;
-                resolver.core.translationUnit = &transUnit;
+                ast::Pass< Resolver_new > resolver( context );
                 return ctorInit->accept( resolver );
         }
@@ -1323 +1320 @@
         ) {
                 assert( stmtExpr );
-                ast::Pass< Resolver_new > resolver{ context.symtab };
-                ast::TranslationUnit transUnit;
-                transUnit.global = context.global;
-                resolver.core.translationUnit = &transUnit;
+                ast::Pass< Resolver_new > resolver( context );
                 auto ret = mutate(stmtExpr->accept(resolver));
                 strict_dynamic_cast< ast::StmtExpr * >( ret )->computeResult();
@@ -1381 +1375 @@
 
                         for (auto & attr: mutDecl->attributes) {
-                                attr = handleAttribute(mutDecl->location, attr, getContext() );
+                                attr = handleAttribute(mutDecl->location, attr, context );
                         }
 
@@ -1394 +1388 @@
                         }
                         for (auto & asst : mutDecl->assertions) {
-                                asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), getContext());
+                                asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), context);
                                 symtab.addId(asst);
                                 mutType->assertions.emplace_back(new ast::VariableExpr(functionDecl->location, asst));
@@ -1406 +1400 @@
 
                         for (auto & param : mutDecl->params) {
-                                param = fixObjectType(param.strict_as<ast::ObjectDecl>(), getContext());
+                                param = fixObjectType(param.strict_as<ast::ObjectDecl>(), context);
                                 symtab.addId(param);
                                 paramTypes.emplace_back(param->get_type());
                         }
                         for (auto & ret : mutDecl->returns) {
-                                ret = fixObjectType(ret.strict_as<ast::ObjectDecl>(), getContext());
+                                ret = fixObjectType(ret.strict_as<ast::ObjectDecl>(), context);
                                 returnTypes.emplace_back(ret->get_type());
                         }
@@ -1482 +1476 @@
                         // enumerator initializers should not use the enum type to initialize, since the
                         // enum type is still incomplete at this point. Use `int` instead.
-                        objectDecl = fixObjectType(objectDecl, getContext());
+                        objectDecl = fixObjectType(objectDecl, context);
                         currentObject = ast::CurrentObject{
                                 objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
@@ -1488 +1482 @@
                 else {
                         if (!objectDecl->isTypeFixed) {
-                                auto newDecl = fixObjectType(objectDecl, getContext());
+                                auto newDecl = fixObjectType(objectDecl, context);
                                 auto mutDecl = mutate(newDecl);
 
@@ -1519 +1513 @@
                         // nested type decls are hoisted already. no need to do anything
                         if (auto obj = member.as<ast::ObjectDecl>()) {
-                                member = fixObjectType(obj, getContext());
+                                member = fixObjectType(obj, context);
                         }
                 }
@@ -1542 +1536 @@
                 return ast::mutate_field(
                         assertDecl, &ast::StaticAssertDecl::cond,
-                        findIntegralExpression( assertDecl->cond, getContext() ) );
+                        findIntegralExpression( assertDecl->cond, context ) );
         }
 
@@ -1557 +1551 @@
 
         const ast::ArrayType * Resolver_new::previsit( const ast::ArrayType * at ) {
-                return handlePtrType( at, getContext() );
+                return handlePtrType( at, context );
         }
 
         const ast::PointerType * Resolver_new::previsit( const ast::PointerType * pt ) {
-                return handlePtrType( pt, getContext() );
+                return handlePtrType( pt, context );
         }
 
@@ -1569 +1563 @@
 
                 return ast::mutate_field(
-                        exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, getContext() ) );
+                        exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, context ) );
         }
 
@@ -1576 +1570 @@
 
                 asmExpr = ast::mutate_field(
-                        asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, getContext() ) );
+                        asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, context ) );
 
                 return asmExpr;
@@ -1590 +1584 @@
         const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
                 return ast::mutate_field(
-                        ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, getContext() ) );
+                        ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) );
         }
 
         const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
                 return ast::mutate_field(
-                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, getContext() ) );
+                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) );
         }
 
@@ -1601 +1595 @@
                 if ( forStmt->cond ) {
                         forStmt = ast::mutate_field(
-                                forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, getContext() ) );
+                                forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, context ) );
                 }
 
                 if ( forStmt->inc ) {
                         forStmt = ast::mutate_field(
-                                forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, getContext() ) );
+                                forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, context ) );
                 }
 
@@ -1616 +1610 @@
                 switchStmt = ast::mutate_field(
                         switchStmt, &ast::SwitchStmt::cond,
-                        findIntegralExpression( switchStmt->cond, getContext() ) );
+                        findIntegralExpression( switchStmt->cond, context ) );
                 currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
                 return switchStmt;
@@ -1629 +1623 @@
                         ast::ptr< ast::Expr > untyped =
                                 new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
-                        ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, getContext() );
+                        ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, context );
 
                         // case condition cannot have a cast in C, so it must be removed here, regardless of
@@ -1650 +1644 @@
                         branchStmt = ast::mutate_field(
                                 branchStmt, &ast::BranchStmt::computedTarget,
-                                findSingleExpression( branchStmt->computedTarget, target, getContext() ) );
+                                findSingleExpression( branchStmt->computedTarget, target, context ) );
                 }
                 return branchStmt;
@@ -1660 +1654 @@
                         returnStmt = ast::mutate_field(
                                 returnStmt, &ast::ReturnStmt::expr,
-                                findSingleExpression( returnStmt->expr, functionReturn, getContext() ) );
+                                findSingleExpression( returnStmt->expr, functionReturn, context ) );
                 }
                 return returnStmt;
@@ -1675 +1669 @@
                         throwStmt = ast::mutate_field(
                                 throwStmt, &ast::ThrowStmt::expr,
-                                findSingleExpression( throwStmt->expr, exceptType, getContext() ) );
+                                findSingleExpression( throwStmt->expr, exceptType, context ) );
                 }
                 return throwStmt;
@@ -1719 +1713 @@
 
                         ast::TypeEnvironment env;
-                        CandidateFinder funcFinder( getContext(), env );
+                        CandidateFinder funcFinder( context, env );
 
                         // Find all candidates for a function in canonical form
@@ -1933 +1927 @@
                                 );
 
-                                clause2.target.args.emplace_back( findSingleExpression( init, getContext() ) );
+                                clause2.target.args.emplace_back( findSingleExpression( init, context ) );
                         }
 
                         // Resolve the conditions as if it were an IfStmt, statements normally
-                        clause2.cond = findSingleExpression( clause.cond, getContext() );
+                        clause2.cond = findSingleExpression( clause.cond, context );
                         clause2.stmt = clause.stmt->accept( *visitor );
 
@@ -1952 +1946 @@
                         ast::ptr< ast::Type > target =
                                 new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
-                        timeout2.time = findSingleExpression( stmt->timeout.time, target, getContext() );
-                        timeout2.cond = findSingleExpression( stmt->timeout.cond, getContext() );
+                        timeout2.time = findSingleExpression( stmt->timeout.time, target, context );
+                        timeout2.cond = findSingleExpression( stmt->timeout.cond, context );
                         timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
 
@@ -1966 +1960 @@
                         ast::WaitForStmt::OrElse orElse2;
 
-                        orElse2.cond = findSingleExpression( stmt->orElse.cond, getContext() );
+                        orElse2.cond = findSingleExpression( stmt->orElse.cond, context );
                         orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
 
@@ -1987 +1981 @@
                 for (auto & expr : exprs) {
                         // only struct- and union-typed expressions are viable candidates
-                        expr = findKindExpression( expr, getContext(), structOrUnion, "with expression" );
+                        expr = findKindExpression( expr, context, structOrUnion, "with expression" );
 
                         // if with expression might be impure, create a temporary so that it is evaluated once
@@ -2013 +2007 @@
                 ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{
                         singleInit->location, singleInit->value, currentObject.getOptions() };
-                ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, getContext() );
+                ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, context );
                 const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();