Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/Resolver.cc

    r4559b34 rb230091  
    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 
    1473                         if (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base) { // const ast::PointerType &
    1474                                 const ast::Type * enumBase =  (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base.get());
    1475                                 const ast::PointerType * enumBaseAsPtr = dynamic_cast<const ast::PointerType *>(enumBase);
    1476 
    1477                                 if ( enumBaseAsPtr ) {
    1478                                         const ast::Type * pointerBase = enumBaseAsPtr->base.get();
    1479                                         if ( dynamic_cast<const ast::BasicType *>(pointerBase) ) {
    1480                                                 objectDecl = fixObjectType(objectDecl, symtab);
    1481                                                 if (dynamic_cast<const ast::BasicType *>(pointerBase)->kind == ast::BasicType::Char)
    1482                                                 currentObject = ast::CurrentObject{
    1483                                                         objectDecl->location,  new ast::PointerType{
    1484                                                                 new ast::BasicType{ ast::BasicType::Char }
    1485                                                         } };
    1486                                         } else {
    1487                                                 objectDecl = fixObjectType(objectDecl, symtab);
    1488                                                 currentObject = ast::CurrentObject{objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
    1489                                         }
    1490                                 }
    1491                         } else {
    1492                                 objectDecl = fixObjectType(objectDecl, symtab);
    1493                                 currentObject = ast::CurrentObject{
    1494                                         objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
    1495                         }
    1496 
     1478                        objectDecl = fixObjectType(objectDecl, context);
     1479                        currentObject = ast::CurrentObject{
     1480                                objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
    14971481                }
    14981482                else {
    14991483                        if (!objectDecl->isTypeFixed) {
    1500                                 auto newDecl = fixObjectType(objectDecl, symtab);
     1484                                auto newDecl = fixObjectType(objectDecl, context);
    15011485                                auto mutDecl = mutate(newDecl);
    15021486
    … …  
    15291513                        // nested type decls are hoisted already. no need to do anything
    15301514                        if (auto obj = member.as<ast::ObjectDecl>()) {
    1531                                 member = fixObjectType(obj, symtab);
     1515                                member = fixObjectType(obj, context);
    15321516                        }
    15331517                }
    … …  
    15521536                return ast::mutate_field(
    15531537                        assertDecl, &ast::StaticAssertDecl::cond,
    1554                         findIntegralExpression( assertDecl->cond, symtab ) );
     1538                        findIntegralExpression( assertDecl->cond, context ) );
    15551539        }
    15561540
    15571541        template< typename PtrType >
    1558         const PtrType * handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
     1542        const PtrType * handlePtrType( const PtrType * type, const ResolveContext & context ) {
    15591543                if ( type->dimension ) {
    1560                         ast::ptr< ast::Type > sizeType = ast::sizeType;
     1544                        ast::ptr< ast::Type > sizeType = context.global.sizeType;
    15611545                        ast::mutate_field(
    15621546                                type, &PtrType::dimension,
    1563                                 findSingleExpression( type->dimension, sizeType, symtab ) );
     1547                                findSingleExpression( type->dimension, sizeType, context ) );
    15641548                }
    15651549                return type;
    … …  
    15671551
    15681552        const ast::ArrayType * Resolver_new::previsit( const ast::ArrayType * at ) {
    1569                 return handlePtrType( at, symtab );
     1553                return handlePtrType( at, context );
    15701554        }
    15711555
    15721556        const ast::PointerType * Resolver_new::previsit( const ast::PointerType * pt ) {
    1573                 return handlePtrType( pt, symtab );
     1557                return handlePtrType( pt, context );
    15741558        }
    15751559
    … …  
    15791563
    15801564                return ast::mutate_field(
    1581                         exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) );
     1565                        exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, context ) );
    15821566        }
    15831567
    … …  
    15861570
    15871571                asmExpr = ast::mutate_field(
    1588                         asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
     1572                        asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, context ) );
    15891573
    15901574                return asmExpr;
    … …  
    16001584        const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
    16011585                return ast::mutate_field(
    1602                         ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, symtab ) );
     1586                        ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) );
    16031587        }
    16041588
    16051589        const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
    16061590                return ast::mutate_field(
    1607                         whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, symtab ) );
     1591                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) );
    16081592        }
    16091593
    … …  
    16111595                if ( forStmt->cond ) {
    16121596                        forStmt = ast::mutate_field(
    1613                                 forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, symtab ) );
     1597                                forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, context ) );
    16141598                }
    16151599
    16161600                if ( forStmt->inc ) {
    16171601                        forStmt = ast::mutate_field(
    1618                                 forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, symtab ) );
     1602                                forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, context ) );
    16191603                }
    16201604
    … …  
    16261610                switchStmt = ast::mutate_field(
    16271611                        switchStmt, &ast::SwitchStmt::cond,
    1628                         findIntegralExpression( switchStmt->cond, symtab ) );
     1612                        findIntegralExpression( switchStmt->cond, context ) );
    16291613                currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
    16301614                return switchStmt;
    16311615        }
    16321616
    1633         const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
     1617        const ast::CaseClause * Resolver_new::previsit( const ast::CaseClause * caseStmt ) {
    16341618                if ( caseStmt->cond ) {
    16351619                        std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
    … …  
    16391623                        ast::ptr< ast::Expr > untyped =
    16401624                                new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
    1641                         ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, symtab );
     1625                        ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, context );
    16421626
    16431627                        // case condition cannot have a cast in C, so it must be removed here, regardless of
    … …  
    16471631                        }
    16481632
    1649                         caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
     1633                        caseStmt = ast::mutate_field( caseStmt, &ast::CaseClause::cond, newExpr );
    16501634                }
    16511635                return caseStmt;
    … …  
    16601644                        branchStmt = ast::mutate_field(
    16611645                                branchStmt, &ast::BranchStmt::computedTarget,
    1662                                 findSingleExpression( branchStmt->computedTarget, target, symtab ) );
     1646                                findSingleExpression( branchStmt->computedTarget, target, context ) );
    16631647                }
    16641648                return branchStmt;
    … …  
    16701654                        returnStmt = ast::mutate_field(
    16711655                                returnStmt, &ast::ReturnStmt::expr,
    1672                                 findSingleExpression( returnStmt->expr, functionReturn, symtab ) );
     1656                                findSingleExpression( returnStmt->expr, functionReturn, context ) );
    16731657                }
    16741658                return returnStmt;
    … …  
    16851669                        throwStmt = ast::mutate_field(
    16861670                                throwStmt, &ast::ThrowStmt::expr,
    1687                                 findSingleExpression( throwStmt->expr, exceptType, symtab ) );
     1671                                findSingleExpression( throwStmt->expr, exceptType, context ) );
    16881672                }
    16891673                return throwStmt;
    16901674        }
    16911675
    1692         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
     1676        const ast::CatchClause * Resolver_new::previsit( const ast::CatchClause * catchClause ) {
    16931677                // Until we are very sure this invarent (ifs that move between passes have then)
    16941678                // holds, check it. This allows a check for when to decode the mangling.
    1695                 if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
     1679                if ( auto ifStmt = catchClause->body.as<ast::IfStmt>() ) {
    16961680                        assert( ifStmt->then );
    16971681                }
    16981682                // Encode the catchStmt so the condition can see the declaration.
    1699                 if ( catchStmt->cond ) {
    1700                         ast::CatchStmt * stmt = mutate( catchStmt );
    1701                         stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
    1702                         stmt->cond = nullptr;
    1703                         return stmt;
    1704                 }
    1705                 return catchStmt;
    1706         }
    1707 
    1708         const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
     1683                if ( catchClause->cond ) {
     1684                        ast::CatchClause * clause = mutate( catchClause );
     1685                        clause->body = new ast::IfStmt( clause->location, clause->cond, nullptr, clause->body );
     1686                        clause->cond = nullptr;
     1687                        return clause;
     1688                }
     1689                return catchClause;
     1690        }
     1691
     1692        const ast::CatchClause * Resolver_new::postvisit( const ast::CatchClause * catchClause ) {
    17091693                // Decode the catchStmt so everything is stored properly.
    1710                 const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
     1694                const ast::IfStmt * ifStmt = catchClause->body.as<ast::IfStmt>();
    17111695                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
    17121696                        assert( ifStmt->cond );
    17131697                        assert( ifStmt->else_ );
    1714                         ast::CatchStmt * stmt = ast::mutate( catchStmt );
    1715                         stmt->cond = ifStmt->cond;
    1716                         stmt->body = ifStmt->else_;
     1698                        ast::CatchClause * clause = ast::mutate( catchClause );
     1699                        clause->cond = ifStmt->cond;
     1700                        clause->body = ifStmt->else_;
    17171701                        // ifStmt should be implicately deleted here.
    1718                         return stmt;
    1719                 }
    1720                 return catchStmt;
     1702                        return clause;
     1703                }
     1704                return catchClause;
    17211705        }
    17221706
    … …  
    17291713
    17301714                        ast::TypeEnvironment env;
    1731                         CandidateFinder funcFinder{ symtab, env };
     1715                        CandidateFinder funcFinder( context, env );
    17321716
    17331717                        // Find all candidates for a function in canonical form
    … …  
    19431927                                );
    19441928
    1945                                 clause2.target.args.emplace_back( findSingleExpression( init, symtab ) );
     1929                                clause2.target.args.emplace_back( findSingleExpression( init, context ) );
    19461930                        }
    19471931
    19481932                        // Resolve the conditions as if it were an IfStmt, statements normally
    1949                         clause2.cond = findSingleExpression( clause.cond, symtab );
     1933                        clause2.cond = findSingleExpression( clause.cond, context );
    19501934                        clause2.stmt = clause.stmt->accept( *visitor );
    19511935
    … …  
    19621946                        ast::ptr< ast::Type > target =
    19631947                                new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
    1964                         timeout2.time = findSingleExpression( stmt->timeout.time, target, symtab );
    1965                         timeout2.cond = findSingleExpression( stmt->timeout.cond, symtab );
     1948                        timeout2.time = findSingleExpression( stmt->timeout.time, target, context );
     1949                        timeout2.cond = findSingleExpression( stmt->timeout.cond, context );
    19661950                        timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
    19671951
    … …  
    19761960                        ast::WaitForStmt::OrElse orElse2;
    19771961
    1978                         orElse2.cond = findSingleExpression( stmt->orElse.cond, symtab );
     1962                        orElse2.cond = findSingleExpression( stmt->orElse.cond, context );
    19791963                        orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
    19801964
    … …  
    19971981                for (auto & expr : exprs) {
    19981982                        // only struct- and union-typed expressions are viable candidates
    1999                         expr = findKindExpression( expr, symtab, structOrUnion, "with expression" );
     1983                        expr = findKindExpression( expr, context, structOrUnion, "with expression" );
    20001984
    20011985                        // if with expression might be impure, create a temporary so that it is evaluated once
    … …  
    20232007                ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{
    20242008                        singleInit->location, singleInit->value, currentObject.getOptions() };
    2025                 ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, symtab );
     2009                ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, context );
    20262010                const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();
    20272011
Note: See TracChangeset for help on using the changeset viewer.