Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    rae265b55 rf6cc734e  
    518518        }
    519519
    520         const ast::Decl * visit( const ast::WithStmt * node ) override final {
     520        const ast::Stmt * visit( const ast::WithStmt * node ) override final {
    521521                if ( inCache( node ) ) return nullptr;
    522522                auto stmt = new WithStmt(
    … …  
    524524                        get<Statement>().accept1( node->stmt )
    525525                );
    526                 declPostamble( stmt, node );
    527                 return nullptr;
     526                return stmtPostamble( stmt, node );
    528527        }
    529528
    … …  
    10511050                                get<Expression>().accept1(node->expr),
    10521051                                inCache(node->deleteStmt) ?
    1053                                         strict_dynamic_cast<Declaration*>(this->node) :
    1054                                         get<Declaration>().accept1(node->deleteStmt)
     1052                                        this->node :
     1053                                        get<BaseSyntaxNode>().accept1(node->deleteStmt)
    10551054                        )
    10561055                );
    … …  
    13671366        ast::Node * node = nullptr;
    13681367        /// cache of nodes that might be referenced by readonly<> for de-duplication
    1369         std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
     1368        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
    13701369
    13711370        // Local Utilities:
    … …  
    14341433                to<std::vector>::from( make_labels( std::move( labels ) ) )
    14351434
    1436         static ast::CV::Qualifiers cv( const Type * ty ) { return { ty->tq.val }; }
     1435        static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
    14371436
    14381437        /// returns true and sets `node` if in cache
    1439         bool inCache( const BaseSyntaxNode * old ) {
     1438        bool inCache( BaseSyntaxNode * old ) {
    14401439                auto it = cache.find( old );
    14411440                if ( it == cache.end() ) return false;
    … …  
    14461445        // Now all the visit functions:
    14471446
    1448         virtual void visit( const ObjectDecl * old ) override final {
     1447        virtual void visit( ObjectDecl * old ) override final {
    14491448                auto&& type = GET_ACCEPT_1(type, Type);
    14501449                auto&& init = GET_ACCEPT_1(init, Init);
    … …  
    14771476        }
    14781477
    1479         virtual void visit( const FunctionDecl * old ) override final {
     1478        virtual void visit( FunctionDecl * old ) override final {
    14801479                if ( inCache( old ) ) return;
    14811480                auto decl = new ast::FunctionDecl{
    … …  
    15101509        }
    15111510
    1512         virtual void visit( const StructDecl * old ) override final {
     1511        virtual void visit( StructDecl * old ) override final {
    15131512                if ( inCache( old ) ) return;
    15141513                auto decl = new ast::StructDecl(
    … …  
    15351534        }
    15361535
    1537         virtual void visit( const UnionDecl * old ) override final {
     1536        virtual void visit( UnionDecl * old ) override final {
    15381537                if ( inCache( old ) ) return;
    15391538                auto decl = new ast::UnionDecl(
    … …  
    15551554        }
    15561555
    1557         virtual void visit( const EnumDecl * old ) override final {
     1556        virtual void visit( EnumDecl * old ) override final {
    15581557                if ( inCache( old ) ) return;
    15591558                auto decl = new ast::EnumDecl(
    … …  
    15751574        }
    15761575
    1577         virtual void visit( const TraitDecl * old ) override final {
     1576        virtual void visit( TraitDecl * old ) override final {
    15781577                if ( inCache( old ) ) return;
    15791578                auto decl = new ast::TraitDecl(
    … …  
    15951594        }
    15961595
    1597         virtual void visit( const TypeDecl * old ) override final {
     1596        virtual void visit( TypeDecl * old ) override final {
    15981597                if ( inCache( old ) ) return;
    15991598                auto decl = new ast::TypeDecl{
    … …  
    16151614        }
    16161615
    1617         virtual void visit( const TypedefDecl * old ) override final {
     1616        virtual void visit( TypedefDecl * old ) override final {
    16181617                auto decl = new ast::TypedefDecl(
    16191618                        old->location,
    … …  
    16321631        }
    16331632
    1634         virtual void visit( const AsmDecl * old ) override final {
     1633        virtual void visit( AsmDecl * old ) override final {
    16351634                auto decl = new ast::AsmDecl{
    16361635                        old->location,
    … …  
    16441643        }
    16451644
    1646         virtual void visit( const StaticAssertDecl * old ) override final {
     1645        virtual void visit( StaticAssertDecl * old ) override final {
    16471646                auto decl = new ast::StaticAssertDecl{
    16481647                        old->location,
    … …  
    16571656        }
    16581657
    1659         virtual void visit( const CompoundStmt * old ) override final {
     1658        virtual void visit( CompoundStmt * old ) override final {
    16601659                if ( inCache( old ) ) return;
    16611660                auto stmt = new ast::CompoundStmt(
    … …  
    16691668        }
    16701669
    1671         virtual void visit( const ExprStmt * old ) override final {
     1670        virtual void visit( ExprStmt * old ) override final {
    16721671                if ( inCache( old ) ) return;
    16731672                this->node = new ast::ExprStmt(
    … …  
    16791678        }
    16801679
    1681         virtual void visit( const AsmStmt * old ) override final {
     1680        virtual void visit( AsmStmt * old ) override final {
    16821681                if ( inCache( old ) ) return;
    16831682                this->node = new ast::AsmStmt(
    … …  
    16941693        }
    16951694
    1696         virtual void visit( const DirectiveStmt * old ) override final {
     1695        virtual void visit( DirectiveStmt * old ) override final {
    16971696                if ( inCache( old ) ) return;
    16981697                this->node = new ast::DirectiveStmt(
    … …  
    17041703        }
    17051704
    1706         virtual void visit( const IfStmt * old ) override final {
     1705        virtual void visit( IfStmt * old ) override final {
    17071706                if ( inCache( old ) ) return;
    17081707                this->node = new ast::IfStmt(
    … …  
    17171716        }
    17181717
    1719         virtual void visit( const SwitchStmt * old ) override final {
     1718        virtual void visit( SwitchStmt * old ) override final {
    17201719                if ( inCache( old ) ) return;
    17211720                this->node = new ast::SwitchStmt(
    … …  
    17281727        }
    17291728
    1730         virtual void visit( const CaseStmt * old ) override final {
     1729        virtual void visit( CaseStmt * old ) override final {
    17311730                if ( inCache( old ) ) return;
    17321731                this->node = new ast::CaseStmt(
    … …  
    17391738        }
    17401739
    1741         virtual void visit( const WhileStmt * old ) override final {
     1740        virtual void visit( WhileStmt * old ) override final {
    17421741                if ( inCache( old ) ) return;
    17431742                this->node = new ast::WhileStmt(
    … …  
    17521751        }
    17531752
    1754         virtual void visit( const ForStmt * old ) override final {
     1753        virtual void visit( ForStmt * old ) override final {
    17551754                if ( inCache( old ) ) return;
    17561755                this->node = new ast::ForStmt(
    … …  
    17651764        }
    17661765
    1767         virtual void visit( const BranchStmt * old ) override final {
     1766        virtual void visit( BranchStmt * old ) override final {
    17681767                if ( inCache( old ) ) return;
    17691768                if (old->computedTarget) {
    … …  
    18021801        }
    18031802
    1804         virtual void visit( const ReturnStmt * old ) override final {
     1803        virtual void visit( ReturnStmt * old ) override final {
    18051804                if ( inCache( old ) ) return;
    18061805                this->node = new ast::ReturnStmt(
    … …  
    18121811        }
    18131812
    1814         virtual void visit( const ThrowStmt * old ) override final {
     1813        virtual void visit( ThrowStmt * old ) override final {
    18151814                if ( inCache( old ) ) return;
    18161815                ast::ExceptionKind kind;
    … …  
    18361835        }
    18371836
    1838         virtual void visit( const TryStmt * old ) override final {
     1837        virtual void visit( TryStmt * old ) override final {
    18391838                if ( inCache( old ) ) return;
    18401839                this->node = new ast::TryStmt(
    … …  
    18481847        }
    18491848
    1850         virtual void visit( const CatchStmt * old ) override final {
     1849        virtual void visit( CatchStmt * old ) override final {
    18511850                if ( inCache( old ) ) return;
    18521851                ast::ExceptionKind kind;
    … …  
    18731872        }
    18741873
    1875         virtual void visit( const FinallyStmt * old ) override final {
     1874        virtual void visit( FinallyStmt * old ) override final {
    18761875                if ( inCache( old ) ) return;
    18771876                this->node = new ast::FinallyStmt(
    … …  
    18831882        }
    18841883
    1885         virtual void visit( const WaitForStmt * old ) override final {
     1884        virtual void visit( WaitForStmt * old ) override final {
    18861885                if ( inCache( old ) ) return;
    18871886                ast::WaitForStmt * stmt = new ast::WaitForStmt(
    … …  
    19151914        }
    19161915
    1917         virtual void visit( const WithStmt * old ) override final {
     1916        virtual void visit( WithStmt * old ) override final {
    19181917                if ( inCache( old ) ) return;
    19191918                this->node = new ast::WithStmt(
    19201919                        old->location,
    19211920                        GET_ACCEPT_V(exprs, Expr),
    1922                         GET_ACCEPT_1(stmt, Stmt)
     1921                        GET_ACCEPT_1(stmt, Stmt),
     1922                        GET_LABELS_V(old->labels)
    19231923                );
    19241924                cache.emplace( old, this->node );
    19251925        }
    19261926
    1927         virtual void visit( const NullStmt * old ) override final {
     1927        virtual void visit( NullStmt * old ) override final {
    19281928                if ( inCache( old ) ) return;
    19291929                this->node = new ast::NullStmt(
    … …  
    19341934        }
    19351935
    1936         virtual void visit( const DeclStmt * old ) override final {
     1936        virtual void visit( DeclStmt * old ) override final {
    19371937                if ( inCache( old ) ) return;
    19381938                this->node = new ast::DeclStmt(
    … …  
    19441944        }
    19451945
    1946         virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
     1946        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
    19471947                if ( inCache( old ) ) return;
    19481948                auto stmt = new ast::ImplicitCtorDtorStmt(
    … …  
    20012001        }
    20022002
    2003         ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
     2003        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
    20042004
    20052005                nw->env    = convertTypeSubstitution(old->env);
    … …  
    20112011        }
    20122012
    2013         ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
     2013        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
    20142014
    20152015                nw->result = GET_ACCEPT_1(result, Type);
    … …  
    20172017        }
    20182018
    2019         virtual void visit( const ApplicationExpr * old ) override final {
     2019        virtual void visit( ApplicationExpr * old ) override final {
    20202020                this->node = visitBaseExpr( old,
    20212021                        new ast::ApplicationExpr(
    … …  
    20272027        }
    20282028
    2029         virtual void visit( const UntypedExpr * old ) override final {
     2029        virtual void visit( UntypedExpr * old ) override final {
    20302030                this->node = visitBaseExpr( old,
    20312031                        new ast::UntypedExpr(
    … …  
    20372037        }
    20382038
    2039         virtual void visit( const NameExpr * old ) override final {
     2039        virtual void visit( NameExpr * old ) override final {
    20402040                this->node = visitBaseExpr( old,
    20412041                        new ast::NameExpr(
    … …  
    20462046        }
    20472047
    2048         virtual void visit( const CastExpr * old ) override final {
     2048        virtual void visit( CastExpr * old ) override final {
    20492049                this->node = visitBaseExpr( old,
    20502050                        new ast::CastExpr(
    … …  
    20562056        }
    20572057
    2058         virtual void visit( const KeywordCastExpr * old) override final {
     2058        virtual void visit( KeywordCastExpr * old) override final {
    20592059                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    20602060                switch (old->target) {
    … …  
    20812081        }
    20822082
    2083         virtual void visit( const VirtualCastExpr * old ) override final {
     2083        virtual void visit( VirtualCastExpr * old ) override final {
    20842084                this->node = visitBaseExpr_SkipResultType( old,
    20852085                        new ast::VirtualCastExpr(
    … …  
    20912091        }
    20922092
    2093         virtual void visit( const AddressExpr * old ) override final {
     2093        virtual void visit( AddressExpr * old ) override final {
    20942094                this->node = visitBaseExpr( old,
    20952095                        new ast::AddressExpr(
    … …  
    21002100        }
    21012101
    2102         virtual void visit( const LabelAddressExpr * old ) override final {
     2102        virtual void visit( LabelAddressExpr * old ) override final {
    21032103                this->node = visitBaseExpr( old,
    21042104                        new ast::LabelAddressExpr(
    … …  
    21092109        }
    21102110
    2111         virtual void visit( const UntypedMemberExpr * old ) override final {
     2111        virtual void visit( UntypedMemberExpr * old ) override final {
    21122112                this->node = visitBaseExpr( old,
    21132113                        new ast::UntypedMemberExpr(
    … …  
    21192119        }
    21202120
    2121         virtual void visit( const MemberExpr * old ) override final {
     2121        virtual void visit( MemberExpr * old ) override final {
    21222122                this->node = visitBaseExpr( old,
    21232123                        new ast::MemberExpr(
    21242124                                old->location,
    21252125                                GET_ACCEPT_1(member, DeclWithType),
    2126                                 GET_ACCEPT_1(aggregate, Expr),
    2127                                 ast::MemberExpr::NoOpConstructionChosen
    2128                         )
    2129                 );
    2130         }
    2131 
    2132         virtual void visit( const VariableExpr * old ) override final {
     2126                                GET_ACCEPT_1(aggregate, Expr)
     2127                        )
     2128                );
     2129        }
     2130
     2131        virtual void visit( VariableExpr * old ) override final {
    21332132                auto expr = new ast::VariableExpr(
    21342133                        old->location
    … …  
    21412140        }
    21422141
    2143         virtual void visit( const ConstantExpr * old ) override final {
     2142        virtual void visit( ConstantExpr * old ) override final {
    21442143                ast::ConstantExpr *rslt = new ast::ConstantExpr(
    21452144                        old->location,
    21462145                        GET_ACCEPT_1(result, Type),
    2147                         old->constant.rep,
     2146                        old->constant.get_value(),
    21482147                        old->constant.ival
    21492148                );
    2150                 rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
     2149                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
    21512150                this->node = visitBaseExpr( old, rslt );
    21522151        }
    21532152
    2154         virtual void visit( const SizeofExpr * old ) override final {
     2153        virtual void visit( SizeofExpr * old ) override final {
    21552154                assert (old->expr || old->type);
    21562155                assert (! (old->expr && old->type));
    … …  
    21732172        }
    21742173
    2175         virtual void visit( const AlignofExpr * old ) override final {
     2174        virtual void visit( AlignofExpr * old ) override final {
    21762175                assert (old->expr || old->type);
    21772176                assert (! (old->expr && old->type));
    … …  
    21942193        }
    21952194
    2196         virtual void visit( const UntypedOffsetofExpr * old ) override final {
     2195        virtual void visit( UntypedOffsetofExpr * old ) override final {
    21972196                this->node = visitBaseExpr( old,
    21982197                        new ast::UntypedOffsetofExpr(
    … …  
    22042203        }
    22052204
    2206         virtual void visit( const OffsetofExpr * old ) override final {
     2205        virtual void visit( OffsetofExpr * old ) override final {
    22072206                this->node = visitBaseExpr( old,
    22082207                        new ast::OffsetofExpr(
    … …  
    22142213        }
    22152214
    2216         virtual void visit( const OffsetPackExpr * old ) override final {
     2215        virtual void visit( OffsetPackExpr * old ) override final {
    22172216                this->node = visitBaseExpr( old,
    22182217                        new ast::OffsetPackExpr(
    … …  
    22232222        }
    22242223
    2225         virtual void visit( const LogicalExpr * old ) override final {
     2224        virtual void visit( LogicalExpr * old ) override final {
    22262225                this->node = visitBaseExpr( old,
    22272226                        new ast::LogicalExpr(
    … …  
    22362235        }
    22372236
    2238         virtual void visit( const ConditionalExpr * old ) override final {
     2237        virtual void visit( ConditionalExpr * old ) override final {
    22392238                this->node = visitBaseExpr( old,
    22402239                        new ast::ConditionalExpr(
    … …  
    22472246        }
    22482247
    2249         virtual void visit( const CommaExpr * old ) override final {
     2248        virtual void visit( CommaExpr * old ) override final {
    22502249                this->node = visitBaseExpr( old,
    22512250                        new ast::CommaExpr(
    … …  
    22572256        }
    22582257
    2259         virtual void visit( const TypeExpr * old ) override final {
     2258        virtual void visit( TypeExpr * old ) override final {
    22602259                this->node = visitBaseExpr( old,
    22612260                        new ast::TypeExpr(
    … …  
    22662265        }
    22672266
    2268         virtual void visit( const AsmExpr * old ) override final {
     2267        virtual void visit( AsmExpr * old ) override final {
    22692268                this->node = visitBaseExpr( old,
    22702269                        new ast::AsmExpr(
    … …  
    22772276        }
    22782277
    2279         virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
     2278        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
    22802279                auto rslt = new ast::ImplicitCopyCtorExpr(
    22812280                        old->location,
    … …  
    22862285        }
    22872286
    2288         virtual void visit( const ConstructorExpr * old ) override final {
     2287        virtual void visit( ConstructorExpr * old ) override final {
    22892288                this->node = visitBaseExpr( old,
    22902289                        new ast::ConstructorExpr(
    … …  
    22952294        }
    22962295
    2297         virtual void visit( const CompoundLiteralExpr * old ) override final {
     2296        virtual void visit( CompoundLiteralExpr * old ) override final {
    22982297                this->node = visitBaseExpr_SkipResultType( old,
    22992298                        new ast::CompoundLiteralExpr(
    … …  
    23052304        }
    23062305
    2307         virtual void visit( const RangeExpr * old ) override final {
     2306        virtual void visit( RangeExpr * old ) override final {
    23082307                this->node = visitBaseExpr( old,
    23092308                        new ast::RangeExpr(
    … …  
    23152314        }
    23162315
    2317         virtual void visit( const UntypedTupleExpr * old ) override final {
     2316        virtual void visit( UntypedTupleExpr * old ) override final {
    23182317                this->node = visitBaseExpr( old,
    23192318                        new ast::UntypedTupleExpr(
    … …  
    23242323        }
    23252324
    2326         virtual void visit( const TupleExpr * old ) override final {
     2325        virtual void visit( TupleExpr * old ) override final {
    23272326                this->node = visitBaseExpr( old,
    23282327                        new ast::TupleExpr(
    … …  
    23332332        }
    23342333
    2335         virtual void visit( const TupleIndexExpr * old ) override final {
     2334        virtual void visit( TupleIndexExpr * old ) override final {
    23362335                this->node = visitBaseExpr( old,
    23372336                        new ast::TupleIndexExpr(
    … …  
    23432342        }
    23442343
    2345         virtual void visit( const TupleAssignExpr * old ) override final {
     2344        virtual void visit( TupleAssignExpr * old ) override final {
    23462345                this->node = visitBaseExpr_SkipResultType( old,
    23472346                        new ast::TupleAssignExpr(
    … …  
    23532352        }
    23542353
    2355         virtual void visit( const StmtExpr * old ) override final {
     2354        virtual void visit( StmtExpr * old ) override final {
    23562355                auto rslt = new ast::StmtExpr(
    23572356                        old->location,
    … …  
    23642363        }
    23652364
    2366         virtual void visit( const UniqueExpr * old ) override final {
     2365        virtual void visit( UniqueExpr * old ) override final {
    23672366                auto rslt = new ast::UniqueExpr(
    23682367                        old->location,
    … …  
    23762375        }
    23772376
    2378         virtual void visit( const UntypedInitExpr * old ) override final {
     2377        virtual void visit( UntypedInitExpr * old ) override final {
    23792378                std::deque<ast::InitAlternative> initAlts;
    23802379                for (auto ia : old->initAlts) {
    … …  
    23932392        }
    23942393
    2395         virtual void visit( const InitExpr * old ) override final {
     2394        virtual void visit( InitExpr * old ) override final {
    23962395                this->node = visitBaseExpr( old,
    23972396                        new ast::InitExpr(
    … …  
    24032402        }
    24042403
    2405         virtual void visit( const DeletedExpr * old ) override final {
     2404        virtual void visit( DeletedExpr * old ) override final {
    24062405                this->node = visitBaseExpr( old,
    24072406                        new ast::DeletedExpr(
    … …  
    24092408                                GET_ACCEPT_1(expr, Expr),
    24102409                                inCache(old->deleteStmt) ?
    2411                                         strict_dynamic_cast<ast::Decl*>(this->node) :
    2412                                         GET_ACCEPT_1(deleteStmt, Decl)
    2413                         )
    2414                 );
    2415         }
    2416 
    2417         virtual void visit( const DefaultArgExpr * old ) override final {
     2410                                        this->node :
     2411                                        GET_ACCEPT_1(deleteStmt, Node)
     2412                        )
     2413                );
     2414        }
     2415
     2416        virtual void visit( DefaultArgExpr * old ) override final {
    24182417                this->node = visitBaseExpr( old,
    24192418                        new ast::DefaultArgExpr(
    … …  
    24242423        }
    24252424
    2426         virtual void visit( const GenericExpr * old ) override final {
     2425        virtual void visit( GenericExpr * old ) override final {
    24272426                std::vector<ast::GenericExpr::Association> associations;
    24282427                for (auto association : old->associations) {
    … …  
    24412440        }
    24422441
    2443         void visitType( const Type * old, ast::Type * type ) {
     2442        void visitType( Type * old, ast::Type * type ) {
    24442443                // Some types do this in their constructor so add a check.
    24452444                if ( !old->attributes.empty() && type->attributes.empty() ) {
    … …  
    24492448        }
    24502449
    2451         virtual void visit( const VoidType * old ) override final {
     2450        virtual void visit( VoidType * old ) override final {
    24522451                visitType( old, new ast::VoidType{ cv( old ) } );
    24532452        }
    24542453
    2455         virtual void visit( const BasicType * old ) override final {
     2454        virtual void visit( BasicType * old ) override final {
    24562455                auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
    24572456                // I believe this should always be a BasicType.
    … …  
    24622461        }
    24632462
    2464         virtual void visit( const PointerType * old ) override final {
     2463        virtual void visit( PointerType * old ) override final {
    24652464                visitType( old, new ast::PointerType{
    24662465                        GET_ACCEPT_1( base, Type ),
    … …  
    24722471        }
    24732472
    2474         virtual void visit( const ArrayType * old ) override final {
     2473        virtual void visit( ArrayType * old ) override final {
    24752474                visitType( old, new ast::ArrayType{
    24762475                        GET_ACCEPT_1( base, Type ),
    … …  
    24822481        }
    24832482
    2484         virtual void visit( const ReferenceType * old ) override final {
     2483        virtual void visit( ReferenceType * old ) override final {
    24852484                visitType( old, new ast::ReferenceType{
    24862485                        GET_ACCEPT_1( base, Type ),
    … …  
    24892488        }
    24902489
    2491         virtual void visit( const QualifiedType * old ) override final {
     2490        virtual void visit( QualifiedType * old ) override final {
    24922491                visitType( old, new ast::QualifiedType{
    24932492                        GET_ACCEPT_1( parent, Type ),
    … …  
    24972496        }
    24982497
    2499         virtual void visit( const FunctionType * old ) override final {
     2498        virtual void visit( FunctionType * old ) override final {
    25002499                auto ty = new ast::FunctionType {
    25012500                        (ast::ArgumentFlag)old->isVarArgs,
    … …  
    25082507        }
    25092508
    2510         void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
     2509        void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
    25112510                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
    25122511                ty->params = GET_ACCEPT_V( parameters, Expr );
    … …  
    25152514        }
    25162515
    2517         virtual void visit( const StructInstType * old ) override final {
     2516        virtual void visit( StructInstType * old ) override final {
    25182517                ast::StructInstType * ty;
    25192518                if ( old->baseStruct ) {
    … …  
    25332532        }
    25342533
    2535         virtual void visit( const UnionInstType * old ) override final {
     2534        virtual void visit( UnionInstType * old ) override final {
    25362535                ast::UnionInstType * ty;
    25372536                if ( old->baseUnion ) {
    … …  
    25512550        }
    25522551
    2553         virtual void visit( const EnumInstType * old ) override final {
     2552        virtual void visit( EnumInstType * old ) override final {
    25542553                ast::EnumInstType * ty;
    25552554                if ( old->baseEnum ) {
    … …  
    25692568        }
    25702569
    2571         virtual void visit( const TraitInstType * old ) override final {
     2570        virtual void visit( TraitInstType * old ) override final {
    25722571                ast::TraitInstType * ty;
    25732572                if ( old->baseTrait ) {
    … …  
    25872586        }
    25882587
    2589         virtual void visit( const TypeInstType * old ) override final {
     2588        virtual void visit( TypeInstType * old ) override final {
    25902589                ast::TypeInstType * ty;
    25912590                if ( old->baseType ) {
    … …  
    26072606        }
    26082607
    2609         virtual void visit( const TupleType * old ) override final {
     2608        virtual void visit( TupleType * old ) override final {
    26102609                visitType( old, new ast::TupleType{
    26112610                        GET_ACCEPT_V( types, Type ),
    … …  
    26152614        }
    26162615
    2617         virtual void visit( const TypeofType * old ) override final {
     2616        virtual void visit( TypeofType * old ) override final {
    26182617                visitType( old, new ast::TypeofType{
    26192618                        GET_ACCEPT_1( expr, Expr ),
    … …  
    26232622        }
    26242623
    2625         virtual void visit( const AttrType * ) override final {
     2624        virtual void visit( AttrType * ) override final {
    26262625                assertf( false, "AttrType deprecated in new AST." );
    26272626        }
    26282627
    2629         virtual void visit( const VarArgsType * old ) override final {
     2628        virtual void visit( VarArgsType * old ) override final {
    26302629                visitType( old, new ast::VarArgsType{ cv( old ) } );
    26312630        }
    26322631
    2633         virtual void visit( const ZeroType * old ) override final {
     2632        virtual void visit( ZeroType * old ) override final {
    26342633                visitType( old, new ast::ZeroType{ cv( old ) } );
    26352634        }
    26362635
    2637         virtual void visit( const OneType * old ) override final {
     2636        virtual void visit( OneType * old ) override final {
    26382637                visitType( old, new ast::OneType{ cv( old ) } );
    26392638        }
    26402639
    2641         virtual void visit( const GlobalScopeType * old ) override final {
     2640        virtual void visit( GlobalScopeType * old ) override final {
    26422641                visitType( old, new ast::GlobalScopeType{} );
    26432642        }
    26442643
    2645         virtual void visit( const Designation * old ) override final {
     2644        virtual void visit( Designation * old ) override final {
    26462645                this->node = new ast::Designation(
    26472646                        old->location,
    … …  
    26502649        }
    26512650
    2652         virtual void visit( const SingleInit * old ) override final {
     2651        virtual void visit( SingleInit * old ) override final {
    26532652                this->node = new ast::SingleInit(
    26542653                        old->location,
    … …  
    26582657        }
    26592658
    2660         virtual void visit( const ListInit * old ) override final {
     2659        virtual void visit( ListInit * old ) override final {
    26612660                this->node = new ast::ListInit(
    26622661                        old->location,
    … …  
    26672666        }
    26682667
    2669         virtual void visit( const ConstructorInit * old ) override final {
     2668        virtual void visit( ConstructorInit * old ) override final {
    26702669                this->node = new ast::ConstructorInit(
    26712670                        old->location,
    … …  
    26762675        }
    26772676
    2678         virtual void visit( const Constant * ) override final {
     2677        virtual void visit( Constant * ) override final {
    26792678                // Handled in visit( ConstantEpxr * ).
    26802679                // In the new tree, Constant fields are inlined into containing ConstantExpression.
    … …  
    26822681        }
    26832682
    2684         virtual void visit( const Attribute * old ) override final {
     2683        virtual void visit( Attribute * old ) override final {
    26852684                this->node = new ast::Attribute(
    26862685                        old->name,
    … …  
    26892688        }
    26902689
    2691         virtual void visit( const AttrExpr * ) override final {
     2690        virtual void visit( AttrExpr * ) override final {
    26922691                assertf( false, "AttrExpr deprecated in new AST." );
    26932692        }
Note: See TracChangeset for help on using the changeset viewer.