Ignore:
Timestamp:
Apr 19, 2022, 3:00:04 PM (3 years ago)
Author:
m3zulfiq <m3zulfiq@…>
Branches:
ADT, ast-experimental, master, pthread-emulation, qualifiedEnum
Children:
5b84a321
Parents:
ba897d21 (diff), bb7c77d (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:

added benchmark and evaluations chapter to thesis

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/Resolver.cc

    rba897d21 r2e9b59b  
    99// Author           : Aaron B. Moss
    1010// Created On       : Sun May 17 12:17:01 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  1 16:27:14 2022
    13 // Update Count     : 245
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Mar 18 10:41:00 2022
     13// Update Count     : 247
    1414//
    1515
    … …  
    997997                /// Calls the CandidateFinder and finds the single best candidate
    998998                CandidateRef findUnfinishedKindExpression(
    999                         const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind,
     999                        const ast::Expr * untyped, const ResolveContext & context, const std::string & kind,
    10001000                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
    10011001                ) {
    … …  
    10071007                        ++recursion_level;
    10081008                        ast::TypeEnvironment env;
    1009                         CandidateFinder finder{ symtab, env };
     1009                        CandidateFinder finder( context, env );
    10101010                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
    10111011                        --recursion_level;
    … …  
    11291129
    11301130        ast::ptr< ast::Expr > resolveInVoidContext(
    1131                 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env
     1131                const ast::Expr * expr, const ResolveContext & context,
     1132                ast::TypeEnvironment & env
    11321133        ) {
    11331134                assertf( expr, "expected a non-null expression" );
    … …  
    11361137                ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
    11371138                CandidateRef choice = findUnfinishedKindExpression(
    1138                         untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
     1139                        untyped, context, "", anyCandidate, ResolvMode::withAdjustment() );
    11391140
    11401141                // a cast expression has either 0 or 1 interpretations (by language rules);
    … …  
    11491150                /// context.
    11501151                ast::ptr< ast::Expr > findVoidExpression(
    1151                         const ast::Expr * untyped, const ast::SymbolTable & symtab
     1152                        const ast::Expr * untyped, const ResolveContext & context
    11521153                ) {
    11531154                        ast::TypeEnvironment env;
    1154                         ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );
     1155                        ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, context, env );
    11551156                        finishExpr( newExpr, env, untyped->env );
    11561157                        return newExpr;
    … …  
    11631164                /// lowest cost, returning the resolved version
    11641165                ast::ptr< ast::Expr > findKindExpression(
    1165                         const ast::Expr * untyped, const ast::SymbolTable & symtab,
     1166                        const ast::Expr * untyped, const ResolveContext & context,
    11661167                        std::function<bool(const Candidate &)> pred = anyCandidate,
    11671168                        const std::string & kind = "", ResolvMode mode = {}
    … …  
    11691170                        if ( ! untyped ) return {};
    11701171                        CandidateRef choice =
    1171                                 findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
     1172                                findUnfinishedKindExpression( untyped, context, kind, pred, mode );
    11721173                        ResolvExpr::finishExpr( choice->expr, choice->env, untyped->env );
    11731174                        return std::move( choice->expr );
    … …  
    11761177                /// Resolve `untyped` to the single expression whose candidate is the best match
    11771178                ast::ptr< ast::Expr > findSingleExpression(
    1178                         const ast::Expr * untyped, const ast::SymbolTable & symtab
     1179                        const ast::Expr * untyped, const ResolveContext & context
    11791180                ) {
    11801181                        Stats::ResolveTime::start( untyped );
    1181                         auto res = findKindExpression( untyped, symtab );
     1182                        auto res = findKindExpression( untyped, context );
    11821183                        Stats::ResolveTime::stop();
    11831184                        return res;
    … …  
    11861187
    11871188        ast::ptr< ast::Expr > findSingleExpression(
    1188                 const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab
     1189                const ast::Expr * untyped, const ast::Type * type,
     1190                const ResolveContext & context
    11891191        ) {
    11901192                assert( untyped && type );
    11911193                ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped, type };
    1192                 ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, symtab );
    1193                 removeExtraneousCast( newExpr, symtab );
     1194                ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, context );
     1195                removeExtraneousCast( newExpr, context.symtab );
    11941196                return newExpr;
    11951197        }
    … …  
    12171219                /// Resolve `untyped` as an integral expression, returning the resolved version
    12181220                ast::ptr< ast::Expr > findIntegralExpression(
    1219                         const ast::Expr * untyped, const ast::SymbolTable & symtab
     1221                        const ast::Expr * untyped, const ResolveContext & context
    12201222                ) {
    1221                         return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
     1223                        return findKindExpression( untyped, context, hasIntegralType, "condition" );
    12221224                }
    12231225
    … …  
    12491251                // for work previously in GenInit
    12501252                static InitTweak::ManagedTypes_new managedTypes;
     1253                ResolveContext context;
    12511254
    12521255                bool inEnumDecl = false;
    … …  
    12541257        public:
    12551258                static size_t traceId;
    1256                 Resolver_new() = default;
    1257                 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
     1259                Resolver_new( const ast::TranslationGlobal & global ) :
     1260                        context{ symtab, global } {}
     1261                Resolver_new( const ResolveContext & context ) :
     1262                        ast::WithSymbolTable{ context.symtab },
     1263                        context{ symtab, context.global } {}
    12581264
    12591265                const ast::FunctionDecl * previsit( const ast::FunctionDecl * );
    … …  
    12721278                const ast::AsmStmt *         previsit( const ast::AsmStmt * );
    12731279                const ast::IfStmt *          previsit( const ast::IfStmt * );
    1274                 const ast::WhileDoStmt *       previsit( const ast::WhileDoStmt * );
     1280                const ast::WhileDoStmt *     previsit( const ast::WhileDoStmt * );
    12751281                const ast::ForStmt *         previsit( const ast::ForStmt * );
    12761282                const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
    1277                 const ast::CaseStmt *        previsit( const ast::CaseStmt * );
     1283                const ast::CaseClause *      previsit( const ast::CaseClause * );
    12781284                const ast::BranchStmt *      previsit( const ast::BranchStmt * );
    12791285                const ast::ReturnStmt *      previsit( const ast::ReturnStmt * );
    12801286                const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
    1281                 const ast::CatchStmt *       previsit( const ast::CatchStmt * );
    1282                 const ast::CatchStmt *       postvisit( const ast::CatchStmt * );
     1287                const ast::CatchClause *     previsit( const ast::CatchClause * );
     1288                const ast::CatchClause *     postvisit( const ast::CatchClause * );
    12831289                const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
    12841290                const ast::WithStmt *        previsit( const ast::WithStmt * );
    … …  
    12991305
    13001306        void resolve( ast::TranslationUnit& translationUnit ) {
    1301                 ast::Pass< Resolver_new >::run( translationUnit );
     1307                ast::Pass< Resolver_new >::run( translationUnit, translationUnit.global );
    13021308        }
    13031309
    13041310        ast::ptr< ast::Init > resolveCtorInit(
    1305                 const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab
     1311                const ast::ConstructorInit * ctorInit, const ResolveContext & context
    13061312        ) {
    13071313                assert( ctorInit );
    1308                 ast::Pass< Resolver_new > resolver{ symtab };
     1314                ast::Pass< Resolver_new > resolver( context );
    13091315                return ctorInit->accept( resolver );
    13101316        }
    13111317
    13121318        const ast::Expr * resolveStmtExpr(
    1313                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab
     1319                const ast::StmtExpr * stmtExpr, const ResolveContext & context
    13141320        ) {
    13151321                assert( stmtExpr );
    1316                 ast::Pass< Resolver_new > resolver{ symtab };
     1322                ast::Pass< Resolver_new > resolver( context );
    13171323                auto ret = mutate(stmtExpr->accept(resolver));
    13181324                strict_dynamic_cast< ast::StmtExpr * >( ret )->computeResult();
    … …  
    13211327
    13221328        namespace {
    1323                 const ast::Attribute * handleAttribute(const CodeLocation & loc, const ast::Attribute * attr, const ast::SymbolTable & symtab) {
     1329                const ast::Attribute * handleAttribute(const CodeLocation & loc, const ast::Attribute * attr, const ResolveContext & context) {
    13241330                        std::string name = attr->normalizedName();
    13251331                        if (name == "constructor" || name == "destructor") {
    13261332                                if (attr->params.size() == 1) {
    13271333                                        auto arg = attr->params.front();
    1328                                         auto resolved = ResolvExpr::findSingleExpression( arg, new ast::BasicType( ast::BasicType::LongLongSignedInt ), symtab );
     1334                                        auto resolved = ResolvExpr::findSingleExpression( arg, new ast::BasicType( ast::BasicType::LongLongSignedInt ), context );
    13291335                                        auto result = eval(arg);
    13301336
    … …  
    13691375
    13701376                        for (auto & attr: mutDecl->attributes) {
    1371                                 attr = handleAttribute(mutDecl->location, attr, symtab);
     1377                                attr = handleAttribute(mutDecl->location, attr, context );
    13721378                        }
    13731379
    … …  
    13791385                        for (auto & typeParam : mutDecl->type_params) {
    13801386                                symtab.addType(typeParam);
    1381                                 mutType->forall.emplace_back(new ast::TypeInstType(typeParam->name, typeParam));
     1387                                mutType->forall.emplace_back(new ast::TypeInstType(typeParam));
    13821388                        }
    13831389                        for (auto & asst : mutDecl->assertions) {
    1384                                 asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), symtab);
     1390                                asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), context);
    13851391                                symtab.addId(asst);
    13861392                                mutType->assertions.emplace_back(new ast::VariableExpr(functionDecl->location, asst));
    … …  
    13941400
    13951401                        for (auto & param : mutDecl->params) {
    1396                                 param = fixObjectType(param.strict_as<ast::ObjectDecl>(), symtab);
     1402                                param = fixObjectType(param.strict_as<ast::ObjectDecl>(), context);
    13971403                                symtab.addId(param);
    13981404                                paramTypes.emplace_back(param->get_type());
    13991405                        }
    14001406                        for (auto & ret : mutDecl->returns) {
    1401                                 ret = fixObjectType(ret.strict_as<ast::ObjectDecl>(), symtab);
     1407                                ret = fixObjectType(ret.strict_as<ast::ObjectDecl>(), context);
    14021408                                returnTypes.emplace_back(ret->get_type());
    14031409                        }
    … …  
    14701476                        // enumerator initializers should not use the enum type to initialize, since the
    14711477                        // enum type is still incomplete at this point. Use `int` instead.
    1472                         objectDecl = fixObjectType(objectDecl, symtab);
    1473                         currentObject = ast::CurrentObject{
    1474                                 objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
     1478
     1479                        if (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base) { // const ast::PointerType &
     1480                                // const ast::Type * enumBase =  (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base.get());
     1481                                // const ast::PointerType * enumBaseAsPtr = dynamic_cast<const ast::PointerType *>(enumBase);
     1482
     1483                                // if ( enumBaseAsPtr ) {
     1484                                //      const ast::Type * pointerBase = enumBaseAsPtr->base.get();
     1485                                //      if ( dynamic_cast<const ast::BasicType *>(pointerBase) ) {
     1486                                //              objectDecl = fixObjectType(objectDecl, context);
     1487                                //              if (dynamic_cast<const ast::BasicType *>(pointerBase)->kind == ast::BasicType::Char)
     1488                                //              currentObject = ast::CurrentObject{
     1489                                //                      objectDecl->location,  new ast::PointerType{
     1490                                //                              new ast::BasicType{ ast::BasicType::Char }
     1491                                //                      } };
     1492                                //      } else {
     1493                                //              objectDecl = fixObjectType(objectDecl, context);
     1494                                //              currentObject = ast::CurrentObject{objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
     1495                                //      }
     1496                                // }
     1497                                objectDecl = fixObjectType( objectDecl, context );
     1498                                const ast::Type * enumBase =  (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base.get());
     1499                                currentObject = ast::CurrentObject{
     1500                                        objectDecl->location,
     1501                                        enumBase
     1502                                };
     1503                        } else {
     1504                                objectDecl = fixObjectType( objectDecl, context );
     1505                                currentObject = ast::CurrentObject{
     1506                                        objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
     1507                        }
     1508
    14751509                }
    14761510                else {
    14771511                        if (!objectDecl->isTypeFixed) {
    1478                                 auto newDecl = fixObjectType(objectDecl, symtab);
     1512                                auto newDecl = fixObjectType(objectDecl, context);
    14791513                                auto mutDecl = mutate(newDecl);
    14801514
    … …  
    15071541                        // nested type decls are hoisted already. no need to do anything
    15081542                        if (auto obj = member.as<ast::ObjectDecl>()) {
    1509                                 member = fixObjectType(obj, symtab);
     1543                                member = fixObjectType(obj, context);
    15101544                        }
    15111545                }
    … …  
    15301564                return ast::mutate_field(
    15311565                        assertDecl, &ast::StaticAssertDecl::cond,
    1532                         findIntegralExpression( assertDecl->cond, symtab ) );
     1566                        findIntegralExpression( assertDecl->cond, context ) );
    15331567        }
    15341568
    15351569        template< typename PtrType >
    1536         const PtrType * handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
     1570        const PtrType * handlePtrType( const PtrType * type, const ResolveContext & context ) {
    15371571                if ( type->dimension ) {
    1538                         ast::ptr< ast::Type > sizeType = ast::sizeType;
     1572                        ast::ptr< ast::Type > sizeType = context.global.sizeType;
    15391573                        ast::mutate_field(
    15401574                                type, &PtrType::dimension,
    1541                                 findSingleExpression( type->dimension, sizeType, symtab ) );
     1575                                findSingleExpression( type->dimension, sizeType, context ) );
    15421576                }
    15431577                return type;
    … …  
    15451579
    15461580        const ast::ArrayType * Resolver_new::previsit( const ast::ArrayType * at ) {
    1547                 return handlePtrType( at, symtab );
     1581                return handlePtrType( at, context );
    15481582        }
    15491583
    15501584        const ast::PointerType * Resolver_new::previsit( const ast::PointerType * pt ) {
    1551                 return handlePtrType( pt, symtab );
     1585                return handlePtrType( pt, context );
    15521586        }
    15531587
    … …  
    15571591
    15581592                return ast::mutate_field(
    1559                         exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) );
     1593                        exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, context ) );
    15601594        }
    15611595
    … …  
    15641598
    15651599                asmExpr = ast::mutate_field(
    1566                         asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
     1600                        asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, context ) );
    15671601
    15681602                return asmExpr;
    … …  
    15781612        const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
    15791613                return ast::mutate_field(
    1580                         ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, symtab ) );
     1614                        ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) );
    15811615        }
    15821616
    15831617        const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
    15841618                return ast::mutate_field(
    1585                         whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, symtab ) );
     1619                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) );
    15861620        }
    15871621
    … …  
    15891623                if ( forStmt->cond ) {
    15901624                        forStmt = ast::mutate_field(
    1591                                 forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, symtab ) );
     1625                                forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, context ) );
    15921626                }
    15931627
    15941628                if ( forStmt->inc ) {
    15951629                        forStmt = ast::mutate_field(
    1596                                 forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, symtab ) );
     1630                                forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, context ) );
    15971631                }
    15981632
    … …  
    16041638                switchStmt = ast::mutate_field(
    16051639                        switchStmt, &ast::SwitchStmt::cond,
    1606                         findIntegralExpression( switchStmt->cond, symtab ) );
     1640                        findIntegralExpression( switchStmt->cond, context ) );
    16071641                currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
    16081642                return switchStmt;
    16091643        }
    16101644
    1611         const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
     1645        const ast::CaseClause * Resolver_new::previsit( const ast::CaseClause * caseStmt ) {
    16121646                if ( caseStmt->cond ) {
    16131647                        std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
    … …  
    16171651                        ast::ptr< ast::Expr > untyped =
    16181652                                new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
    1619                         ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, symtab );
     1653                        ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, context );
    16201654
    16211655                        // case condition cannot have a cast in C, so it must be removed here, regardless of
    … …  
    16251659                        }
    16261660
    1627                         caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
     1661                        caseStmt = ast::mutate_field( caseStmt, &ast::CaseClause::cond, newExpr );
    16281662                }
    16291663                return caseStmt;
    … …  
    16381672                        branchStmt = ast::mutate_field(
    16391673                                branchStmt, &ast::BranchStmt::computedTarget,
    1640                                 findSingleExpression( branchStmt->computedTarget, target, symtab ) );
     1674                                findSingleExpression( branchStmt->computedTarget, target, context ) );
    16411675                }
    16421676                return branchStmt;
    … …  
    16481682                        returnStmt = ast::mutate_field(
    16491683                                returnStmt, &ast::ReturnStmt::expr,
    1650                                 findSingleExpression( returnStmt->expr, functionReturn, symtab ) );
     1684                                findSingleExpression( returnStmt->expr, functionReturn, context ) );
    16511685                }
    16521686                return returnStmt;
    … …  
    16631697                        throwStmt = ast::mutate_field(
    16641698                                throwStmt, &ast::ThrowStmt::expr,
    1665                                 findSingleExpression( throwStmt->expr, exceptType, symtab ) );
     1699                                findSingleExpression( throwStmt->expr, exceptType, context ) );
    16661700                }
    16671701                return throwStmt;
    16681702        }
    16691703
    1670         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
     1704        const ast::CatchClause * Resolver_new::previsit( const ast::CatchClause * catchClause ) {
    16711705                // Until we are very sure this invarent (ifs that move between passes have then)
    16721706                // holds, check it. This allows a check for when to decode the mangling.
    1673                 if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
     1707                if ( auto ifStmt = catchClause->body.as<ast::IfStmt>() ) {
    16741708                        assert( ifStmt->then );
    16751709                }
    16761710                // Encode the catchStmt so the condition can see the declaration.
    1677                 if ( catchStmt->cond ) {
    1678                         ast::CatchStmt * stmt = mutate( catchStmt );
    1679                         stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
    1680                         stmt->cond = nullptr;
    1681                         return stmt;
    1682                 }
    1683                 return catchStmt;
    1684         }
    1685 
    1686         const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
     1711                if ( catchClause->cond ) {
     1712                        ast::CatchClause * clause = mutate( catchClause );
     1713                        clause->body = new ast::IfStmt( clause->location, clause->cond, nullptr, clause->body );
     1714                        clause->cond = nullptr;
     1715                        return clause;
     1716                }
     1717                return catchClause;
     1718        }
     1719
     1720        const ast::CatchClause * Resolver_new::postvisit( const ast::CatchClause * catchClause ) {
    16871721                // Decode the catchStmt so everything is stored properly.
    1688                 const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
     1722                const ast::IfStmt * ifStmt = catchClause->body.as<ast::IfStmt>();
    16891723                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
    16901724                        assert( ifStmt->cond );
    16911725                        assert( ifStmt->else_ );
    1692                         ast::CatchStmt * stmt = ast::mutate( catchStmt );
    1693                         stmt->cond = ifStmt->cond;
    1694                         stmt->body = ifStmt->else_;
     1726                        ast::CatchClause * clause = ast::mutate( catchClause );
     1727                        clause->cond = ifStmt->cond;
     1728                        clause->body = ifStmt->else_;
    16951729                        // ifStmt should be implicately deleted here.
    1696                         return stmt;
    1697                 }
    1698                 return catchStmt;
     1730                        return clause;
     1731                }
     1732                return catchClause;
    16991733        }
    17001734
    … …  
    17071741
    17081742                        ast::TypeEnvironment env;
    1709                         CandidateFinder funcFinder{ symtab, env };
     1743                        CandidateFinder funcFinder( context, env );
    17101744
    17111745                        // Find all candidates for a function in canonical form
    … …  
    19211955                                );
    19221956
    1923                                 clause2.target.args.emplace_back( findSingleExpression( init, symtab ) );
     1957                                clause2.target.args.emplace_back( findSingleExpression( init, context ) );
    19241958                        }
    19251959
    19261960                        // Resolve the conditions as if it were an IfStmt, statements normally
    1927                         clause2.cond = findSingleExpression( clause.cond, symtab );
     1961                        clause2.cond = findSingleExpression( clause.cond, context );
    19281962                        clause2.stmt = clause.stmt->accept( *visitor );
    19291963
    … …  
    19401974                        ast::ptr< ast::Type > target =
    19411975                                new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
    1942                         timeout2.time = findSingleExpression( stmt->timeout.time, target, symtab );
    1943                         timeout2.cond = findSingleExpression( stmt->timeout.cond, symtab );
     1976                        timeout2.time = findSingleExpression( stmt->timeout.time, target, context );
     1977                        timeout2.cond = findSingleExpression( stmt->timeout.cond, context );
    19441978                        timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
    19451979
    … …  
    19541988                        ast::WaitForStmt::OrElse orElse2;
    19551989
    1956                         orElse2.cond = findSingleExpression( stmt->orElse.cond, symtab );
     1990                        orElse2.cond = findSingleExpression( stmt->orElse.cond, context );
    19571991                        orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
    19581992
    … …  
    19752009                for (auto & expr : exprs) {
    19762010                        // only struct- and union-typed expressions are viable candidates
    1977                         expr = findKindExpression( expr, symtab, structOrUnion, "with expression" );
     2011                        expr = findKindExpression( expr, context, structOrUnion, "with expression" );
    19782012
    19792013                        // if with expression might be impure, create a temporary so that it is evaluated once
    … …  
    20012035                ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{
    20022036                        singleInit->location, singleInit->value, currentObject.getOptions() };
    2003                 ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, symtab );
     2037                ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, context );
    20042038                const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();
    20052039
Note: See TracChangeset for help on using the changeset viewer.