Changeset 0e42794


Ignore:
Timestamp:
Jun 5, 2019, 11:24:10 AM (3 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
d4b6638
Parents:
93744b5
Message:

Rewrite WithSymbolTable? pass accessory to use ast::SymbolTable?

Location:
src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Pass.hpp

    r93744b5 r0e42794  
    3333#include "AST/Visitor.hpp"
    3434
    35 #include "SymTab/Indexer.h"
     35#include "AST/SymbolTable.hpp"
    3636
    3737// Private prelude header, needed for some of the magic tricks this class pulls off
     
    6161//                          postvisit/postmutate teminates.
    6262// | WithVisitorRef       - provides an pointer to the templated visitor wrapper
    63 // | WithIndexer          - provides indexer functionality (i.e. up-to-date symbol table)
     63// | WithSymbolTable      - provides symbol table functionality
    6464//-------------------------------------------------------------------------------------------------
    6565template< typename pass_t >
     
    206206
    207207private:
    208         /// Internal RAII guard for indexer features
    209         struct guard_indexer {
    210                 guard_indexer( Pass<pass_t> & pass ): pass( pass ) { __pass::indexer::enter(pass, 0); }
    211                 ~guard_indexer()                                   { __pass::indexer::leave(pass, 0); }
     208        /// Internal RAII guard for symbol table features
     209        struct guard_symtab {
     210                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
     211                ~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
    212212                Pass<pass_t> & pass;
    213213        };
     
    294294};
    295295
    296 /// Use when the templated visitor should update the indexer
    297 struct WithIndexer {
    298         SymTab::Indexer indexer;
     296/// Use when the templated visitor should update the symbol table
     297struct WithSymbolTable {
     298        SymbolTable symtab;
    299299};
    300300}
  • src/AST/Pass.impl.hpp

    r93744b5 r0e42794  
    398398        VISIT(
    399399                {
    400                         guard_indexer guard { *this };
     400                        guard_symtab guard { *this };
    401401                        maybe_accept( node, &ObjectDecl::type );
    402402                }
     
    406406        )
    407407
    408         __pass::indexer::addId( pass, 0, node );
     408        __pass::symtab::addId( pass, 0, node );
    409409
    410410        VISIT_END( DeclWithType, node );
     
    417417        VISIT_START( node );
    418418
    419         __pass::indexer::addId( pass, 0, node );
     419        __pass::symtab::addId( pass, 0, node );
    420420
    421421        VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
    422422        {
    423423                // with clause introduces a level of scope (for the with expression members).
    424                 // with clause exprs are added to the indexer before parameters so that parameters
     424                // with clause exprs are added to the symbol table before parameters so that parameters
    425425                // shadow with exprs and not the other way around.
    426                 guard_indexer guard { *this };
    427                 __pass::indexer::addWith( pass, 0, node->withExprs, node );
     426                guard_symtab guard { *this };
     427                __pass::symtab::addWith( pass, 0, node->withExprs, node );
    428428                {
    429                         guard_indexer guard { *this };
     429                        guard_symtab guard { *this };
    430430                        // implicit add __func__ identifier as specified in the C manual 6.4.2.2
    431431                        static ast::ObjectDecl func(
     
    436436                                )
    437437                        );
    438                         __pass::indexer::addId( pass, 0, &func );
     438                        __pass::symtab::addId( pass, 0, &func );
    439439                        VISIT(
    440440                                maybe_accept( node, &FunctionDecl::type );
     
    460460        // make up a forward declaration and add it before processing the members
    461461        // needs to be on the heap because addStruct saves the pointer
    462         __pass::indexer::addStructFwd( pass, 0, node );
    463 
    464         VISIT({
    465                 guard_indexer guard { * this };
     462        __pass::symtab::addStructFwd( pass, 0, node );
     463
     464        VISIT({
     465                guard_symtab guard { * this };
    466466                maybe_accept( node, &StructDecl::params  );
    467467                maybe_accept( node, &StructDecl::members );
     
    469469
    470470        // this addition replaces the forward declaration
    471         __pass::indexer::addStruct( pass, 0, node );
     471        __pass::symtab::addStruct( pass, 0, node );
    472472
    473473        VISIT_END( Decl, node );
     
    481481
    482482        // make up a forward declaration and add it before processing the members
    483         __pass::indexer::addUnionFwd( pass, 0, node );
    484 
    485         VISIT({
    486                 guard_indexer guard { * this };
     483        __pass::symtab::addUnionFwd( pass, 0, node );
     484
     485        VISIT({
     486                guard_symtab guard { * this };
    487487                maybe_accept( node, &UnionDecl::params  );
    488488                maybe_accept( node, &UnionDecl::members );
    489489        })
    490490
    491         __pass::indexer::addUnion( pass, 0, node );
     491        __pass::symtab::addUnion( pass, 0, node );
    492492
    493493        VISIT_END( Decl, node );
     
    500500        VISIT_START( node );
    501501
    502         __pass::indexer::addEnum( pass, 0, node );
     502        __pass::symtab::addEnum( pass, 0, node );
    503503
    504504        VISIT(
     
    518518
    519519        VISIT({
    520                 guard_indexer guard { *this };
     520                guard_symtab guard { *this };
    521521                maybe_accept( node, &TraitDecl::params  );
    522522                maybe_accept( node, &TraitDecl::members );
    523523        })
    524524
    525         __pass::indexer::addTrait( pass, 0, node );
     525        __pass::symtab::addTrait( pass, 0, node );
    526526
    527527        VISIT_END( Decl, node );
     
    535535
    536536        VISIT({
    537                 guard_indexer guard { *this };
     537                guard_symtab guard { *this };
    538538                maybe_accept( node, &TypeDecl::params );
    539539                maybe_accept( node, &TypeDecl::base   );
     
    543543        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
    544544        // and may depend on the type itself
    545         __pass::indexer::addType( pass, 0, node );
     545        __pass::symtab::addType( pass, 0, node );
    546546
    547547        VISIT(
     
    549549
    550550                {
    551                         guard_indexer guard { *this };
     551                        guard_symtab guard { *this };
    552552                        maybe_accept( node, &TypeDecl::init );
    553553                }
     
    564564
    565565        VISIT({
    566                 guard_indexer guard { *this };
     566                guard_symtab guard { *this };
    567567                maybe_accept( node, &TypedefDecl::params );
    568568                maybe_accept( node, &TypedefDecl::base   );
    569569        })
    570570
    571         __pass::indexer::addType( pass, 0, node );
     571        __pass::symtab::addType( pass, 0, node );
    572572
    573573        VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
     
    611611                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
    612612                auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() {
    613                         if ( ! inFunction ) __pass::indexer::enter(pass, 0);
     613                        if ( ! inFunction ) __pass::symtab::enter(pass, 0);
    614614                }, [this, inFunction = this->inFunction]() {
    615                         if ( ! inFunction ) __pass::indexer::leave(pass, 0);
     615                        if ( ! inFunction ) __pass::symtab::leave(pass, 0);
    616616                });
    617617                ValueGuard< bool > guard2( inFunction );
     
    669669        VISIT({
    670670                // if statements introduce a level of scope (for the initialization)
    671                 guard_indexer guard { *this };
     671                guard_symtab guard { *this };
    672672                maybe_accept( node, &IfStmt::inits    );
    673673                maybe_accept( node, &IfStmt::cond     );
     
    687687        VISIT({
    688688                // while statements introduce a level of scope (for the initialization)
    689                 guard_indexer guard { *this };
     689                guard_symtab guard { *this };
    690690                maybe_accept( node, &WhileStmt::inits );
    691691                maybe_accept( node, &WhileStmt::cond  );
     
    704704        VISIT({
    705705                // for statements introduce a level of scope (for the initialization)
    706                 guard_indexer guard { *this };
     706                guard_symtab guard { *this };
    707707                maybe_accept( node, &ForStmt::inits );
    708708                maybe_accept( node, &ForStmt::cond  );
     
    800800        VISIT({
    801801                // catch statements introduce a level of scope (for the caught exception)
    802                 guard_indexer guard { *this };
     802                guard_symtab guard { *this };
    803803                maybe_accept( node, &CatchStmt::decl );
    804804                maybe_accept( node, &CatchStmt::cond );
     
    901901                {
    902902                        // catch statements introduce a level of scope (for the caught exception)
    903                         guard_indexer guard { *this };
    904                         __pass::indexer::addWith( pass, 0, node->exprs, node );
     903                        guard_symtab guard { *this };
     904                        __pass::symtab::addWith( pass, 0, node->exprs, node );
    905905                        maybe_accept( node, &WithStmt::stmt );
    906906                }
     
    953953        VISIT(
    954954                {
    955                         guard_indexer guard { *this };
     955                        guard_symtab guard { *this };
    956956                        maybe_accept( node, &ApplicationExpr::result );
    957957                }
     
    971971        VISIT(
    972972                {
    973                         guard_indexer guard { *this };
     973                        guard_symtab guard { *this };
    974974                        maybe_accept( node, &UntypedExpr::result );
    975975                }
     
    988988
    989989        VISIT({
    990                 guard_indexer guard { *this };
     990                guard_symtab guard { *this };
    991991                maybe_accept( node, &NameExpr::result );
    992992        })
     
    10021002
    10031003        VISIT({
    1004                         guard_indexer guard { *this };
     1004                        guard_symtab guard { *this };
    10051005                        maybe_accept( node, &CastExpr::result );
    10061006                }
     
    10181018
    10191019        VISIT({
    1020                         guard_indexer guard { *this };
     1020                        guard_symtab guard { *this };
    10211021                        maybe_accept( node, &KeywordCastExpr::result );
    10221022                }
     
    10341034
    10351035        VISIT({
    1036                         guard_indexer guard { *this };
     1036                        guard_symtab guard { *this };
    10371037                        maybe_accept( node, &VirtualCastExpr::result );
    10381038                }
     
    10501050
    10511051        VISIT({
    1052                         guard_indexer guard { *this };
     1052                        guard_symtab guard { *this };
    10531053                        maybe_accept( node, &AddressExpr::result );
    10541054                }
     
    10661066
    10671067        VISIT({
    1068                 guard_indexer guard { *this };
     1068                guard_symtab guard { *this };
    10691069                maybe_accept( node, &LabelAddressExpr::result );
    10701070        })
     
    10801080
    10811081        VISIT({
    1082                         guard_indexer guard { *this };
     1082                        guard_symtab guard { *this };
    10831083                        maybe_accept( node, &UntypedMemberExpr::result );
    10841084                }
     
    10971097
    10981098        VISIT({
    1099                         guard_indexer guard { *this };
     1099                        guard_symtab guard { *this };
    11001100                        maybe_accept( node, &MemberExpr::result );
    11011101                }
     
    11131113
    11141114        VISIT({
    1115                 guard_indexer guard { *this };
     1115                guard_symtab guard { *this };
    11161116                maybe_accept( node, &VariableExpr::result );
    11171117        })
     
    11271127
    11281128        VISIT({
    1129                 guard_indexer guard { *this };
     1129                guard_symtab guard { *this };
    11301130                maybe_accept( node, &ConstantExpr::result );
    11311131        })
     
    11411141
    11421142        VISIT({
    1143                         guard_indexer guard { *this };
     1143                        guard_symtab guard { *this };
    11441144                        maybe_accept( node, &SizeofExpr::result );
    11451145                }
     
    11611161
    11621162        VISIT({
    1163                         guard_indexer guard { *this };
     1163                        guard_symtab guard { *this };
    11641164                        maybe_accept( node, &AlignofExpr::result );
    11651165                }
     
    11811181
    11821182        VISIT({
    1183                         guard_indexer guard { *this };
     1183                        guard_symtab guard { *this };
    11841184                        maybe_accept( node, &UntypedOffsetofExpr::result );
    11851185                }
     
    11971197
    11981198        VISIT({
    1199                         guard_indexer guard { *this };
     1199                        guard_symtab guard { *this };
    12001200                        maybe_accept( node, &OffsetofExpr::result );
    12011201                }
     
    12131213
    12141214        VISIT({
    1215                         guard_indexer guard { *this };
     1215                        guard_symtab guard { *this };
    12161216                        maybe_accept( node, &OffsetPackExpr::result );
    12171217                }
     
    12291229
    12301230        VISIT({
    1231                         guard_indexer guard { *this };
     1231                        guard_symtab guard { *this };
    12321232                        maybe_accept( node, &LogicalExpr::result );
    12331233                }
     
    12461246
    12471247        VISIT({
    1248                         guard_indexer guard { *this };
     1248                        guard_symtab guard { *this };
    12491249                        maybe_accept( node, &ConditionalExpr::result );
    12501250                }
     
    12641264
    12651265        VISIT({
    1266                         guard_indexer guard { *this };
     1266                        guard_symtab guard { *this };
    12671267                        maybe_accept( node, &CommaExpr::result );
    12681268                }
     
    12811281
    12821282        VISIT({
    1283                         guard_indexer guard { *this };
     1283                        guard_symtab guard { *this };
    12841284                        maybe_accept( node, &TypeExpr::result );
    12851285                }
     
    12971297
    12981298        VISIT({
    1299                         guard_indexer guard { *this };
     1299                        guard_symtab guard { *this };
    13001300                        maybe_accept( node, &AsmExpr::result );
    13011301                }
     
    13151315
    13161316        VISIT({
    1317                         guard_indexer guard { *this };
     1317                        guard_symtab guard { *this };
    13181318                        maybe_accept( node, &ImplicitCopyCtorExpr::result );
    13191319                }
     
    13311331
    13321332        VISIT({
    1333                         guard_indexer guard { *this };
     1333                        guard_symtab guard { *this };
    13341334                        maybe_accept( node, &ConstructorExpr::result );
    13351335                }
     
    13471347
    13481348        VISIT({
    1349                         guard_indexer guard { *this };
     1349                        guard_symtab guard { *this };
    13501350                        maybe_accept( node, &CompoundLiteralExpr::result );
    13511351                }
     
    13631363
    13641364        VISIT({
    1365                         guard_indexer guard { *this };
     1365                        guard_symtab guard { *this };
    13661366                        maybe_accept( node, &RangeExpr::result );
    13671367                }
     
    13801380
    13811381        VISIT({
    1382                         guard_indexer guard { *this };
     1382                        guard_symtab guard { *this };
    13831383                        maybe_accept( node, &UntypedTupleExpr::result );
    13841384                }
     
    13961396
    13971397        VISIT({
    1398                         guard_indexer guard { *this };
     1398                        guard_symtab guard { *this };
    13991399                        maybe_accept( node, &TupleExpr::result );
    14001400                }
     
    14121412
    14131413        VISIT({
    1414                         guard_indexer guard { *this };
     1414                        guard_symtab guard { *this };
    14151415                        maybe_accept( node, &TupleIndexExpr::result );
    14161416                }
     
    14281428
    14291429        VISIT({
    1430                         guard_indexer guard { *this };
     1430                        guard_symtab guard { *this };
    14311431                        maybe_accept( node, &TupleAssignExpr::result );
    14321432                }
     
    14541454
    14551455                {
    1456                         guard_indexer guard { *this };
     1456                        guard_symtab guard { *this };
    14571457                        maybe_accept( node, &StmtExpr::result );
    14581458                }
     
    14721472
    14731473        VISIT({
    1474                         guard_indexer guard { *this };
     1474                        guard_symtab guard { *this };
    14751475                        maybe_accept( node, &UniqueExpr::result );
    14761476                }
     
    14881488
    14891489        VISIT({
    1490                         guard_indexer guard { *this };
     1490                        guard_symtab guard { *this };
    14911491                        maybe_accept( node, &UntypedInitExpr::result );
    14921492                }
     
    15051505
    15061506        VISIT({
    1507                         guard_indexer guard { *this };
     1507                        guard_symtab guard { *this };
    15081508                        maybe_accept( node, &InitExpr::result );
    15091509                }
     
    15221522
    15231523        VISIT({
    1524                         guard_indexer guard { *this };
     1524                        guard_symtab guard { *this };
    15251525                        maybe_accept( node, &DeletedExpr::result );
    15261526                }
     
    15391539
    15401540        VISIT({
    1541                         guard_indexer guard { *this };
     1541                        guard_symtab guard { *this };
    15421542                        maybe_accept( node, &DefaultArgExpr::result );
    15431543                }
     
    15551555
    15561556        VISIT({
    1557                         guard_indexer guard { *this };
     1557                        guard_symtab guard { *this };
    15581558                        maybe_accept( node, &GenericExpr::result );
    15591559                }
     
    15661566                        const Type * type = nullptr;
    15671567                        if( assoc.type ) {
    1568                                 guard_indexer guard { *this };
     1568                                guard_symtab guard { *this };
    15691569                                type = assoc.type->accept( *this );
    15701570                                if( type != assoc.type ) mutated = true;
     
    16821682        VISIT_START( node );
    16831683
    1684         __pass::indexer::addStruct( pass, 0, node->name );
    1685 
    1686         VISIT({
    1687                 guard_indexer guard { *this };
     1684        __pass::symtab::addStruct( pass, 0, node->name );
     1685
     1686        VISIT({
     1687                guard_symtab guard { *this };
    16881688                maybe_accept( node, &StructInstType::forall );
    16891689                maybe_accept( node, &StructInstType::params );
     
    16991699        VISIT_START( node );
    17001700
    1701         __pass::indexer::addStruct( pass, 0, node->name );
     1701        __pass::symtab::addStruct( pass, 0, node->name );
    17021702
    17031703        {
    1704                 guard_indexer guard { *this };
     1704                guard_symtab guard { *this };
    17051705                maybe_accept( node, &UnionInstType::forall );
    17061706                maybe_accept( node, &UnionInstType::params );
     
    18931893                        std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
    18941894                        for ( const auto & p : node->typeEnv ) {
    1895                                 guard_indexer guard { *this };
     1895                                guard_symtab guard { *this };
    18961896                                auto new_node = p.second->accept( *this );
    18971897                                if (new_node != p.second) mutated = false;
     
    19091909                        std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
    19101910                        for ( const auto & p : node->varEnv ) {
    1911                                 guard_indexer guard { *this };
     1911                                guard_symtab guard { *this };
    19121912                                auto new_node = p.second->accept( *this );
    19131913                                if (new_node != p.second) mutated = false;
  • src/AST/Pass.proto.hpp

    r93744b5 r0e42794  
    265265        };
    266266
    267         // Finally certain pass desire an up to date indexer automatically
    268         // detect the presence of a member name indexer and call all the members appropriately
    269         namespace indexer {
     267        // Finally certain pass desire an up to date symbol table automatically
     268        // detect the presence of a member name `symtab` and call all the members appropriately
     269        namespace symtab {
    270270                // Some simple scoping rules
    271271                template<typename pass_t>
    272                 static inline auto enter( pass_t & pass, int ) -> decltype( pass.indexer.enterScope(), void() ) {
    273                         pass.indexer.enterScope();
     272                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) {
     273                        pass.symtab.enterScope();
    274274                }
    275275
     
    278278
    279279                template<typename pass_t>
    280                 static inline auto leave( pass_t & pass, int ) -> decltype( pass.indexer.leaveScope(), void() ) {
    281                         pass.indexer.leaveScope();
     280                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), void() ) {
     281                        pass.symtab.leaveScope();
    282282                }
    283283
     
    285285                static inline auto leave( pass_t &, long ) {}
    286286
    287                 // The indexer has 2 kind of functions mostly, 1 argument and 2 arguments
     287                // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
    288288                // Create macro to condense these common patterns
    289                 #define INDEXER_FUNC1( func, type ) \
     289                #define SYMTAB_FUNC1( func, type ) \
    290290                template<typename pass_t> \
    291                 static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.indexer.func( arg ), void() ) {\
    292                         pass.indexer.func( arg ); \
     291                static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.symtab.func( arg ), void() ) {\
     292                        pass.symtab.func( arg ); \
    293293                } \
    294294                \
     
    296296                static inline void func( pass_t &, long, type ) {}
    297297
    298                 #define INDEXER_FUNC2( func, type1, type2 ) \
     298                #define SYMTAB_FUNC2( func, type1, type2 ) \
    299299                template<typename pass_t> \
    300                 static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.indexer.func( arg1, arg2 ), void () ) {\
    301                         pass.indexer.func( arg1, arg2 ); \
     300                static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.symtab.func( arg1, arg2 ), void () ) {\
     301                        pass.symtab.func( arg1, arg2 ); \
    302302                } \
    303303                        \
     
    305305                static inline void func( pass_t &, long, type1, type2 ) {}
    306306
    307                 INDEXER_FUNC1( addId     , const DeclWithType *  );
    308                 INDEXER_FUNC1( addType   , const NamedTypeDecl * );
    309                 INDEXER_FUNC1( addStruct , const StructDecl *    );
    310                 INDEXER_FUNC1( addEnum   , const EnumDecl *      );
    311                 INDEXER_FUNC1( addUnion  , const UnionDecl *     );
    312                 INDEXER_FUNC1( addTrait  , const TraitDecl *     );
    313                 INDEXER_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
     307                SYMTAB_FUNC1( addId     , const DeclWithType *  );
     308                SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
     309                SYMTAB_FUNC1( addStruct , const StructDecl *    );
     310                SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
     311                SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
     312                SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
     313                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
    314314
    315315                // A few extra functions have more complicated behaviour, they are hand written
    316316                template<typename pass_t>
    317                 static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
     317                static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.symtab.addStruct( decl ), void() ) {
    318318                        ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
    319319                        fwd->params = decl->params;
    320                         pass.indexer.addStruct( fwd );
     320                        pass.symtab.addStruct( fwd );
    321321                }
    322322
     
    325325
    326326                template<typename pass_t>
    327                 static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
     327                static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.symtab.addUnion( decl ), void() ) {
    328328                        UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
    329329                        fwd->params = decl->params;
    330                         pass.indexer.addUnion( fwd );
     330                        pass.symtab.addUnion( fwd );
    331331                }
    332332
     
    335335
    336336                template<typename pass_t>
    337                 static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addStruct( str ), void() ) {
    338                         if ( ! pass.indexer.lookupStruct( str ) ) {
    339                                 pass.indexer.addStruct( str );
     337                static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addStruct( str ), void() ) {
     338                        if ( ! pass.symtab.lookupStruct( str ) ) {
     339                                pass.symtab.addStruct( str );
    340340                        }
    341341                }
     
    345345
    346346                template<typename pass_t>
    347                 static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) {
    348                         if ( ! pass.indexer.lookupUnion( str ) ) {
    349                                 pass.indexer.addUnion( str );
     347                static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addUnion( str ), void() ) {
     348                        if ( ! pass.symtab.lookupUnion( str ) ) {
     349                                pass.symtab.addUnion( str );
    350350                        }
    351351                }
     
    354354                static inline void addUnion( pass_t &, long, const std::string & ) {}
    355355
    356                 #undef INDEXER_FUNC1
    357                 #undef INDEXER_FUNC2
     356                #undef SYMTAB_FUNC1
     357                #undef SYMTAB_FUNC2
    358358        };
    359359};
  • src/AST/SymbolTable.hpp

    r93744b5 r0e42794  
    123123        void addType( const NamedTypeDecl * decl );
    124124        /// Adds a struct declaration to the symbol table by name
    125         void addStruct( const std::string &id );
     125        void addStruct( const std::string & id );
    126126        /// Adds a struct declaration to the symbol table
    127127        void addStruct( const StructDecl * decl );
    128128        /// Adds an enum declaration to the symbol table
    129         void addEnum( const EnumDecl *decl );
     129        void addEnum( const EnumDecl * decl );
    130130        /// Adds a union declaration to the symbol table by name
    131         void addUnion( const std::string &id );
     131        void addUnion( const std::string & id );
    132132        /// Adds a union declaration to the symbol table
    133133        void addUnion( const UnionDecl * decl );
  • src/AST/porting.md

    r93744b5 r0e42794  
    109109    * `SymTab::Indexer` => `ast::SymbolTable`
    110110    * `SymTab/Indexer.{h,cc}` => `AST/SymbolTable.{hpp,cpp}`
    111     * **TODO** `WithIndexer` => `WithSymbolTable`
     111    * `WithIndexer` => `WithSymbolTable`
    112112      * `indexer` => `symTab`
    113113    * `IdData::deleteStmt` => `IdData::deleter`
    114114    * `lookupId()` now returns a vector rather than an out-param list
    115     * To avoid name collisions:
    116       * `SymTab::Mangler` => `Mangle`
     115  * To avoid name collisions:
     116    * `SymTab::Mangler` => `Mangle`
    117117  * `ResolvExpr::TypeEnvironment` => `ast::TypeEnvironment`
    118118    * in `AST/TypeEnvironment.hpp`
  • src/ResolvExpr/Resolver.cc

    r93744b5 r0e42794  
    938938
    939939        class Resolver_new final
    940         : public ast::WithIndexer, public ast::WithGuards, public ast::WithVisitorRef<Resolver_new>,
    941           public ast::WithShortCircuiting, public ast::WithStmtsToAdd<> {
     940        : public ast::WithSymbolTable, public ast::WithGuards,
     941          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
     942          public ast::WithStmtsToAdd<> {
    942943                 
    943944        public:
    944945                Resolver_new() = default;
    945                 Resolver_new( const ast::SymbolTable & syms ) { /*symtab = syms;*/ }
     946                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
    946947
    947948                void previsit( ast::FunctionDecl * functionDecl );
Note: See TracChangeset for help on using the changeset viewer.