Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    re67991f 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
    … …  
    608607
    609608                tgt->result = get<Type>().accept1(src->result);
     609                // Unconditionally use a clone of the result type.
     610                // We know this will leak some objects: much of the immediate conversion result.
     611                // In some cases, using the conversion result directly gives unintended object sharing.
     612                // A parameter (ObjectDecl, a child of a FunctionType) is shared by the weak-ref cache.
     613                // But tgt->result must be fully owned privately by tgt.
     614                // Applying these conservative copies here means
     615                // - weak references point at the declaration's copy, not these expr.result copies (good)
     616                // - we copy more objects than really needed (bad, tolerated)
     617                if (tgt->result) {
     618                        tgt->result = tgt->result->clone();
     619                }
    610620                return visitBaseExpr_skipResultType(src, tgt);
    611621        }
    … …  
    10401050                                get<Expression>().accept1(node->expr),
    10411051                                inCache(node->deleteStmt) ?
    1042                                         strict_dynamic_cast<Declaration*>(this->node) :
    1043                                         get<Declaration>().accept1(node->deleteStmt)
     1052                                        this->node :
     1053                                        get<BaseSyntaxNode>().accept1(node->deleteStmt)
    10441054                        )
    10451055                );
    … …  
    13561366        ast::Node * node = nullptr;
    13571367        /// cache of nodes that might be referenced by readonly<> for de-duplication
    1358         std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
     1368        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
    13591369
    13601370        // Local Utilities:
    … …  
    14231433                to<std::vector>::from( make_labels( std::move( labels ) ) )
    14241434
    1425         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 }; }
    14261436
    14271437        /// returns true and sets `node` if in cache
    1428         bool inCache( const BaseSyntaxNode * old ) {
     1438        bool inCache( BaseSyntaxNode * old ) {
    14291439                auto it = cache.find( old );
    14301440                if ( it == cache.end() ) return false;
    … …  
    14351445        // Now all the visit functions:
    14361446
    1437         virtual void visit( const ObjectDecl * old ) override final {
     1447        virtual void visit( ObjectDecl * old ) override final {
    14381448                auto&& type = GET_ACCEPT_1(type, Type);
    14391449                auto&& init = GET_ACCEPT_1(init, Init);
    … …  
    14661476        }
    14671477
    1468         virtual void visit( const FunctionDecl * old ) override final {
     1478        virtual void visit( FunctionDecl * old ) override final {
    14691479                if ( inCache( old ) ) return;
    14701480                auto decl = new ast::FunctionDecl{
    … …  
    14991509        }
    15001510
    1501         virtual void visit( const StructDecl * old ) override final {
     1511        virtual void visit( StructDecl * old ) override final {
    15021512                if ( inCache( old ) ) return;
    15031513                auto decl = new ast::StructDecl(
    … …  
    15241534        }
    15251535
    1526         virtual void visit( const UnionDecl * old ) override final {
     1536        virtual void visit( UnionDecl * old ) override final {
    15271537                if ( inCache( old ) ) return;
    15281538                auto decl = new ast::UnionDecl(
    … …  
    15441554        }
    15451555
    1546         virtual void visit( const EnumDecl * old ) override final {
     1556        virtual void visit( EnumDecl * old ) override final {
    15471557                if ( inCache( old ) ) return;
    15481558                auto decl = new ast::EnumDecl(
    … …  
    15641574        }
    15651575
    1566         virtual void visit( const TraitDecl * old ) override final {
     1576        virtual void visit( TraitDecl * old ) override final {
    15671577                if ( inCache( old ) ) return;
    15681578                auto decl = new ast::TraitDecl(
    … …  
    15841594        }
    15851595
    1586         virtual void visit( const TypeDecl * old ) override final {
     1596        virtual void visit( TypeDecl * old ) override final {
    15871597                if ( inCache( old ) ) return;
    15881598                auto decl = new ast::TypeDecl{
    … …  
    16041614        }
    16051615
    1606         virtual void visit( const TypedefDecl * old ) override final {
     1616        virtual void visit( TypedefDecl * old ) override final {
    16071617                auto decl = new ast::TypedefDecl(
    16081618                        old->location,
    … …  
    16211631        }
    16221632
    1623         virtual void visit( const AsmDecl * old ) override final {
     1633        virtual void visit( AsmDecl * old ) override final {
    16241634                auto decl = new ast::AsmDecl{
    16251635                        old->location,
    … …  
    16331643        }
    16341644
    1635         virtual void visit( const StaticAssertDecl * old ) override final {
     1645        virtual void visit( StaticAssertDecl * old ) override final {
    16361646                auto decl = new ast::StaticAssertDecl{
    16371647                        old->location,
    … …  
    16461656        }
    16471657
    1648         virtual void visit( const CompoundStmt * old ) override final {
     1658        virtual void visit( CompoundStmt * old ) override final {
    16491659                if ( inCache( old ) ) return;
    16501660                auto stmt = new ast::CompoundStmt(
    … …  
    16581668        }
    16591669
    1660         virtual void visit( const ExprStmt * old ) override final {
     1670        virtual void visit( ExprStmt * old ) override final {
    16611671                if ( inCache( old ) ) return;
    16621672                this->node = new ast::ExprStmt(
    … …  
    16681678        }
    16691679
    1670         virtual void visit( const AsmStmt * old ) override final {
     1680        virtual void visit( AsmStmt * old ) override final {
    16711681                if ( inCache( old ) ) return;
    16721682                this->node = new ast::AsmStmt(
    … …  
    16831693        }
    16841694
    1685         virtual void visit( const DirectiveStmt * old ) override final {
     1695        virtual void visit( DirectiveStmt * old ) override final {
    16861696                if ( inCache( old ) ) return;
    16871697                this->node = new ast::DirectiveStmt(
    … …  
    16931703        }
    16941704
    1695         virtual void visit( const IfStmt * old ) override final {
     1705        virtual void visit( IfStmt * old ) override final {
    16961706                if ( inCache( old ) ) return;
    16971707                this->node = new ast::IfStmt(
    … …  
    17061716        }
    17071717
    1708         virtual void visit( const SwitchStmt * old ) override final {
     1718        virtual void visit( SwitchStmt * old ) override final {
    17091719                if ( inCache( old ) ) return;
    17101720                this->node = new ast::SwitchStmt(
    … …  
    17171727        }
    17181728
    1719         virtual void visit( const CaseStmt * old ) override final {
     1729        virtual void visit( CaseStmt * old ) override final {
    17201730                if ( inCache( old ) ) return;
    17211731                this->node = new ast::CaseStmt(
    … …  
    17281738        }
    17291739
    1730         virtual void visit( const WhileStmt * old ) override final {
     1740        virtual void visit( WhileStmt * old ) override final {
    17311741                if ( inCache( old ) ) return;
    17321742                this->node = new ast::WhileStmt(
    … …  
    17411751        }
    17421752
    1743         virtual void visit( const ForStmt * old ) override final {
     1753        virtual void visit( ForStmt * old ) override final {
    17441754                if ( inCache( old ) ) return;
    17451755                this->node = new ast::ForStmt(
    … …  
    17541764        }
    17551765
    1756         virtual void visit( const BranchStmt * old ) override final {
     1766        virtual void visit( BranchStmt * old ) override final {
    17571767                if ( inCache( old ) ) return;
    17581768                if (old->computedTarget) {
    … …  
    17911801        }
    17921802
    1793         virtual void visit( const ReturnStmt * old ) override final {
     1803        virtual void visit( ReturnStmt * old ) override final {
    17941804                if ( inCache( old ) ) return;
    17951805                this->node = new ast::ReturnStmt(
    … …  
    18011811        }
    18021812
    1803         virtual void visit( const ThrowStmt * old ) override final {
     1813        virtual void visit( ThrowStmt * old ) override final {
    18041814                if ( inCache( old ) ) return;
    18051815                ast::ExceptionKind kind;
    … …  
    18251835        }
    18261836
    1827         virtual void visit( const TryStmt * old ) override final {
     1837        virtual void visit( TryStmt * old ) override final {
    18281838                if ( inCache( old ) ) return;
    18291839                this->node = new ast::TryStmt(
    … …  
    18371847        }
    18381848
    1839         virtual void visit( const CatchStmt * old ) override final {
     1849        virtual void visit( CatchStmt * old ) override final {
    18401850                if ( inCache( old ) ) return;
    18411851                ast::ExceptionKind kind;
    … …  
    18621872        }
    18631873
    1864         virtual void visit( const FinallyStmt * old ) override final {
     1874        virtual void visit( FinallyStmt * old ) override final {
    18651875                if ( inCache( old ) ) return;
    18661876                this->node = new ast::FinallyStmt(
    … …  
    18721882        }
    18731883
    1874         virtual void visit( const WaitForStmt * old ) override final {
     1884        virtual void visit( WaitForStmt * old ) override final {
    18751885                if ( inCache( old ) ) return;
    18761886                ast::WaitForStmt * stmt = new ast::WaitForStmt(
    … …  
    19041914        }
    19051915
    1906         virtual void visit( const WithStmt * old ) override final {
     1916        virtual void visit( WithStmt * old ) override final {
    19071917                if ( inCache( old ) ) return;
    19081918                this->node = new ast::WithStmt(
    19091919                        old->location,
    19101920                        GET_ACCEPT_V(exprs, Expr),
    1911                         GET_ACCEPT_1(stmt, Stmt)
     1921                        GET_ACCEPT_1(stmt, Stmt),
     1922                        GET_LABELS_V(old->labels)
    19121923                );
    19131924                cache.emplace( old, this->node );
    19141925        }
    19151926
    1916         virtual void visit( const NullStmt * old ) override final {
     1927        virtual void visit( NullStmt * old ) override final {
    19171928                if ( inCache( old ) ) return;
    19181929                this->node = new ast::NullStmt(
    … …  
    19231934        }
    19241935
    1925         virtual void visit( const DeclStmt * old ) override final {
     1936        virtual void visit( DeclStmt * old ) override final {
    19261937                if ( inCache( old ) ) return;
    19271938                this->node = new ast::DeclStmt(
    … …  
    19331944        }
    19341945
    1935         virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
     1946        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
    19361947                if ( inCache( old ) ) return;
    19371948                auto stmt = new ast::ImplicitCtorDtorStmt(
    … …  
    19902001        }
    19912002
    1992         ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
     2003        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
    19932004
    19942005                nw->env    = convertTypeSubstitution(old->env);
    … …  
    20002011        }
    20012012
    2002         ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
     2013        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
    20032014
    20042015                nw->result = GET_ACCEPT_1(result, Type);
    … …  
    20062017        }
    20072018
    2008         virtual void visit( const ApplicationExpr * old ) override final {
     2019        virtual void visit( ApplicationExpr * old ) override final {
    20092020                this->node = visitBaseExpr( old,
    20102021                        new ast::ApplicationExpr(
    … …  
    20162027        }
    20172028
    2018         virtual void visit( const UntypedExpr * old ) override final {
     2029        virtual void visit( UntypedExpr * old ) override final {
    20192030                this->node = visitBaseExpr( old,
    20202031                        new ast::UntypedExpr(
    … …  
    20262037        }
    20272038
    2028         virtual void visit( const NameExpr * old ) override final {
     2039        virtual void visit( NameExpr * old ) override final {
    20292040                this->node = visitBaseExpr( old,
    20302041                        new ast::NameExpr(
    … …  
    20352046        }
    20362047
    2037         virtual void visit( const CastExpr * old ) override final {
     2048        virtual void visit( CastExpr * old ) override final {
    20382049                this->node = visitBaseExpr( old,
    20392050                        new ast::CastExpr(
    … …  
    20452056        }
    20462057
    2047         virtual void visit( const KeywordCastExpr * old) override final {
     2058        virtual void visit( KeywordCastExpr * old) override final {
    20482059                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    20492060                switch (old->target) {
    … …  
    20702081        }
    20712082
    2072         virtual void visit( const VirtualCastExpr * old ) override final {
     2083        virtual void visit( VirtualCastExpr * old ) override final {
    20732084                this->node = visitBaseExpr_SkipResultType( old,
    20742085                        new ast::VirtualCastExpr(
    … …  
    20802091        }
    20812092
    2082         virtual void visit( const AddressExpr * old ) override final {
     2093        virtual void visit( AddressExpr * old ) override final {
    20832094                this->node = visitBaseExpr( old,
    20842095                        new ast::AddressExpr(
    … …  
    20892100        }
    20902101
    2091         virtual void visit( const LabelAddressExpr * old ) override final {
     2102        virtual void visit( LabelAddressExpr * old ) override final {
    20922103                this->node = visitBaseExpr( old,
    20932104                        new ast::LabelAddressExpr(
    … …  
    20982109        }
    20992110
    2100         virtual void visit( const UntypedMemberExpr * old ) override final {
     2111        virtual void visit( UntypedMemberExpr * old ) override final {
    21012112                this->node = visitBaseExpr( old,
    21022113                        new ast::UntypedMemberExpr(
    … …  
    21082119        }
    21092120
    2110         virtual void visit( const MemberExpr * old ) override final {
     2121        virtual void visit( MemberExpr * old ) override final {
    21112122                this->node = visitBaseExpr( old,
    21122123                        new ast::MemberExpr(
    … …  
    21182129        }
    21192130
    2120         virtual void visit( const VariableExpr * old ) override final {
     2131        virtual void visit( VariableExpr * old ) override final {
    21212132                auto expr = new ast::VariableExpr(
    21222133                        old->location
    … …  
    21292140        }
    21302141
    2131         virtual void visit( const ConstantExpr * old ) override final {
     2142        virtual void visit( ConstantExpr * old ) override final {
    21322143                ast::ConstantExpr *rslt = new ast::ConstantExpr(
    21332144                        old->location,
    21342145                        GET_ACCEPT_1(result, Type),
    2135                         old->constant.rep,
     2146                        old->constant.get_value(),
    21362147                        old->constant.ival
    21372148                );
    2138                 rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
     2149                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
    21392150                this->node = visitBaseExpr( old, rslt );
    21402151        }
    21412152
    2142         virtual void visit( const SizeofExpr * old ) override final {
     2153        virtual void visit( SizeofExpr * old ) override final {
    21432154                assert (old->expr || old->type);
    21442155                assert (! (old->expr && old->type));
    … …  
    21612172        }
    21622173
    2163         virtual void visit( const AlignofExpr * old ) override final {
     2174        virtual void visit( AlignofExpr * old ) override final {
    21642175                assert (old->expr || old->type);
    21652176                assert (! (old->expr && old->type));
    … …  
    21822193        }
    21832194
    2184         virtual void visit( const UntypedOffsetofExpr * old ) override final {
     2195        virtual void visit( UntypedOffsetofExpr * old ) override final {
    21852196                this->node = visitBaseExpr( old,
    21862197                        new ast::UntypedOffsetofExpr(
    … …  
    21922203        }
    21932204
    2194         virtual void visit( const OffsetofExpr * old ) override final {
     2205        virtual void visit( OffsetofExpr * old ) override final {
    21952206                this->node = visitBaseExpr( old,
    21962207                        new ast::OffsetofExpr(
    … …  
    22022213        }
    22032214
    2204         virtual void visit( const OffsetPackExpr * old ) override final {
     2215        virtual void visit( OffsetPackExpr * old ) override final {
    22052216                this->node = visitBaseExpr( old,
    22062217                        new ast::OffsetPackExpr(
    … …  
    22112222        }
    22122223
    2213         virtual void visit( const LogicalExpr * old ) override final {
     2224        virtual void visit( LogicalExpr * old ) override final {
    22142225                this->node = visitBaseExpr( old,
    22152226                        new ast::LogicalExpr(
    … …  
    22242235        }
    22252236
    2226         virtual void visit( const ConditionalExpr * old ) override final {
     2237        virtual void visit( ConditionalExpr * old ) override final {
    22272238                this->node = visitBaseExpr( old,
    22282239                        new ast::ConditionalExpr(
    … …  
    22352246        }
    22362247
    2237         virtual void visit( const CommaExpr * old ) override final {
     2248        virtual void visit( CommaExpr * old ) override final {
    22382249                this->node = visitBaseExpr( old,
    22392250                        new ast::CommaExpr(
    … …  
    22452256        }
    22462257
    2247         virtual void visit( const TypeExpr * old ) override final {
     2258        virtual void visit( TypeExpr * old ) override final {
    22482259                this->node = visitBaseExpr( old,
    22492260                        new ast::TypeExpr(
    … …  
    22542265        }
    22552266
    2256         virtual void visit( const AsmExpr * old ) override final {
     2267        virtual void visit( AsmExpr * old ) override final {
    22572268                this->node = visitBaseExpr( old,
    22582269                        new ast::AsmExpr(
    … …  
    22652276        }
    22662277
    2267         virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
     2278        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
    22682279                auto rslt = new ast::ImplicitCopyCtorExpr(
    22692280                        old->location,
    … …  
    22742285        }
    22752286
    2276         virtual void visit( const ConstructorExpr * old ) override final {
     2287        virtual void visit( ConstructorExpr * old ) override final {
    22772288                this->node = visitBaseExpr( old,
    22782289                        new ast::ConstructorExpr(
    … …  
    22832294        }
    22842295
    2285         virtual void visit( const CompoundLiteralExpr * old ) override final {
     2296        virtual void visit( CompoundLiteralExpr * old ) override final {
    22862297                this->node = visitBaseExpr_SkipResultType( old,
    22872298                        new ast::CompoundLiteralExpr(
    … …  
    22932304        }
    22942305
    2295         virtual void visit( const RangeExpr * old ) override final {
     2306        virtual void visit( RangeExpr * old ) override final {
    22962307                this->node = visitBaseExpr( old,
    22972308                        new ast::RangeExpr(
    … …  
    23032314        }
    23042315
    2305         virtual void visit( const UntypedTupleExpr * old ) override final {
     2316        virtual void visit( UntypedTupleExpr * old ) override final {
    23062317                this->node = visitBaseExpr( old,
    23072318                        new ast::UntypedTupleExpr(
    … …  
    23122323        }
    23132324
    2314         virtual void visit( const TupleExpr * old ) override final {
     2325        virtual void visit( TupleExpr * old ) override final {
    23152326                this->node = visitBaseExpr( old,
    23162327                        new ast::TupleExpr(
    … …  
    23212332        }
    23222333
    2323         virtual void visit( const TupleIndexExpr * old ) override final {
     2334        virtual void visit( TupleIndexExpr * old ) override final {
    23242335                this->node = visitBaseExpr( old,
    23252336                        new ast::TupleIndexExpr(
    … …  
    23312342        }
    23322343
    2333         virtual void visit( const TupleAssignExpr * old ) override final {
     2344        virtual void visit( TupleAssignExpr * old ) override final {
    23342345                this->node = visitBaseExpr_SkipResultType( old,
    23352346                        new ast::TupleAssignExpr(
    … …  
    23412352        }
    23422353
    2343         virtual void visit( const StmtExpr * old ) override final {
     2354        virtual void visit( StmtExpr * old ) override final {
    23442355                auto rslt = new ast::StmtExpr(
    23452356                        old->location,
    … …  
    23522363        }
    23532364
    2354         virtual void visit( const UniqueExpr * old ) override final {
     2365        virtual void visit( UniqueExpr * old ) override final {
    23552366                auto rslt = new ast::UniqueExpr(
    23562367                        old->location,
    … …  
    23642375        }
    23652376
    2366         virtual void visit( const UntypedInitExpr * old ) override final {
     2377        virtual void visit( UntypedInitExpr * old ) override final {
    23672378                std::deque<ast::InitAlternative> initAlts;
    23682379                for (auto ia : old->initAlts) {
    … …  
    23812392        }
    23822393
    2383         virtual void visit( const InitExpr * old ) override final {
     2394        virtual void visit( InitExpr * old ) override final {
    23842395                this->node = visitBaseExpr( old,
    23852396                        new ast::InitExpr(
    … …  
    23912402        }
    23922403
    2393         virtual void visit( const DeletedExpr * old ) override final {
     2404        virtual void visit( DeletedExpr * old ) override final {
    23942405                this->node = visitBaseExpr( old,
    23952406                        new ast::DeletedExpr(
    … …  
    23972408                                GET_ACCEPT_1(expr, Expr),
    23982409                                inCache(old->deleteStmt) ?
    2399                                         strict_dynamic_cast<ast::Decl*>(this->node) :
    2400                                         GET_ACCEPT_1(deleteStmt, Decl)
    2401                         )
    2402                 );
    2403         }
    2404 
    2405         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 {
    24062417                this->node = visitBaseExpr( old,
    24072418                        new ast::DefaultArgExpr(
    … …  
    24122423        }
    24132424
    2414         virtual void visit( const GenericExpr * old ) override final {
     2425        virtual void visit( GenericExpr * old ) override final {
    24152426                std::vector<ast::GenericExpr::Association> associations;
    24162427                for (auto association : old->associations) {
    … …  
    24292440        }
    24302441
    2431         void visitType( const Type * old, ast::Type * type ) {
     2442        void visitType( Type * old, ast::Type * type ) {
    24322443                // Some types do this in their constructor so add a check.
    24332444                if ( !old->attributes.empty() && type->attributes.empty() ) {
    … …  
    24372448        }
    24382449
    2439         virtual void visit( const VoidType * old ) override final {
     2450        virtual void visit( VoidType * old ) override final {
    24402451                visitType( old, new ast::VoidType{ cv( old ) } );
    24412452        }
    24422453
    2443         virtual void visit( const BasicType * old ) override final {
     2454        virtual void visit( BasicType * old ) override final {
    24442455                auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
    24452456                // I believe this should always be a BasicType.
    … …  
    24502461        }
    24512462
    2452         virtual void visit( const PointerType * old ) override final {
     2463        virtual void visit( PointerType * old ) override final {
    24532464                visitType( old, new ast::PointerType{
    24542465                        GET_ACCEPT_1( base, Type ),
    … …  
    24602471        }
    24612472
    2462         virtual void visit( const ArrayType * old ) override final {
     2473        virtual void visit( ArrayType * old ) override final {
    24632474                visitType( old, new ast::ArrayType{
    24642475                        GET_ACCEPT_1( base, Type ),
    … …  
    24702481        }
    24712482
    2472         virtual void visit( const ReferenceType * old ) override final {
     2483        virtual void visit( ReferenceType * old ) override final {
    24732484                visitType( old, new ast::ReferenceType{
    24742485                        GET_ACCEPT_1( base, Type ),
    … …  
    24772488        }
    24782489
    2479         virtual void visit( const QualifiedType * old ) override final {
     2490        virtual void visit( QualifiedType * old ) override final {
    24802491                visitType( old, new ast::QualifiedType{
    24812492                        GET_ACCEPT_1( parent, Type ),
    … …  
    24852496        }
    24862497
    2487         virtual void visit( const FunctionType * old ) override final {
     2498        virtual void visit( FunctionType * old ) override final {
    24882499                auto ty = new ast::FunctionType {
    24892500                        (ast::ArgumentFlag)old->isVarArgs,
    … …  
    24962507        }
    24972508
    2498         void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
     2509        void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
    24992510                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
    25002511                ty->params = GET_ACCEPT_V( parameters, Expr );
    … …  
    25032514        }
    25042515
    2505         virtual void visit( const StructInstType * old ) override final {
     2516        virtual void visit( StructInstType * old ) override final {
    25062517                ast::StructInstType * ty;
    25072518                if ( old->baseStruct ) {
    … …  
    25212532        }
    25222533
    2523         virtual void visit( const UnionInstType * old ) override final {
     2534        virtual void visit( UnionInstType * old ) override final {
    25242535                ast::UnionInstType * ty;
    25252536                if ( old->baseUnion ) {
    … …  
    25392550        }
    25402551
    2541         virtual void visit( const EnumInstType * old ) override final {
     2552        virtual void visit( EnumInstType * old ) override final {
    25422553                ast::EnumInstType * ty;
    25432554                if ( old->baseEnum ) {
    … …  
    25572568        }
    25582569
    2559         virtual void visit( const TraitInstType * old ) override final {
     2570        virtual void visit( TraitInstType * old ) override final {
    25602571                ast::TraitInstType * ty;
    25612572                if ( old->baseTrait ) {
    … …  
    25752586        }
    25762587
    2577         virtual void visit( const TypeInstType * old ) override final {
     2588        virtual void visit( TypeInstType * old ) override final {
    25782589                ast::TypeInstType * ty;
    25792590                if ( old->baseType ) {
    … …  
    25952606        }
    25962607
    2597         virtual void visit( const TupleType * old ) override final {
     2608        virtual void visit( TupleType * old ) override final {
    25982609                visitType( old, new ast::TupleType{
    25992610                        GET_ACCEPT_V( types, Type ),
    … …  
    26032614        }
    26042615
    2605         virtual void visit( const TypeofType * old ) override final {
     2616        virtual void visit( TypeofType * old ) override final {
    26062617                visitType( old, new ast::TypeofType{
    26072618                        GET_ACCEPT_1( expr, Expr ),
    … …  
    26112622        }
    26122623
    2613         virtual void visit( const AttrType * ) override final {
     2624        virtual void visit( AttrType * ) override final {
    26142625                assertf( false, "AttrType deprecated in new AST." );
    26152626        }
    26162627
    2617         virtual void visit( const VarArgsType * old ) override final {
     2628        virtual void visit( VarArgsType * old ) override final {
    26182629                visitType( old, new ast::VarArgsType{ cv( old ) } );
    26192630        }
    26202631
    2621         virtual void visit( const ZeroType * old ) override final {
     2632        virtual void visit( ZeroType * old ) override final {
    26222633                visitType( old, new ast::ZeroType{ cv( old ) } );
    26232634        }
    26242635
    2625         virtual void visit( const OneType * old ) override final {
     2636        virtual void visit( OneType * old ) override final {
    26262637                visitType( old, new ast::OneType{ cv( old ) } );
    26272638        }
    26282639
    2629         virtual void visit( const GlobalScopeType * old ) override final {
     2640        virtual void visit( GlobalScopeType * old ) override final {
    26302641                visitType( old, new ast::GlobalScopeType{} );
    26312642        }
    26322643
    2633         virtual void visit( const Designation * old ) override final {
     2644        virtual void visit( Designation * old ) override final {
    26342645                this->node = new ast::Designation(
    26352646                        old->location,
    … …  
    26382649        }
    26392650
    2640         virtual void visit( const SingleInit * old ) override final {
     2651        virtual void visit( SingleInit * old ) override final {
    26412652                this->node = new ast::SingleInit(
    26422653                        old->location,
    … …  
    26462657        }
    26472658
    2648         virtual void visit( const ListInit * old ) override final {
     2659        virtual void visit( ListInit * old ) override final {
    26492660                this->node = new ast::ListInit(
    26502661                        old->location,
    … …  
    26552666        }
    26562667
    2657         virtual void visit( const ConstructorInit * old ) override final {
     2668        virtual void visit( ConstructorInit * old ) override final {
    26582669                this->node = new ast::ConstructorInit(
    26592670                        old->location,
    … …  
    26642675        }
    26652676
    2666         virtual void visit( const Constant * ) override final {
     2677        virtual void visit( Constant * ) override final {
    26672678                // Handled in visit( ConstantEpxr * ).
    26682679                // In the new tree, Constant fields are inlined into containing ConstantExpression.
    … …  
    26702681        }
    26712682
    2672         virtual void visit( const Attribute * old ) override final {
     2683        virtual void visit( Attribute * old ) override final {
    26732684                this->node = new ast::Attribute(
    26742685                        old->name,
    … …  
    26772688        }
    26782689
    2679         virtual void visit( const AttrExpr * ) override final {
     2690        virtual void visit( AttrExpr * ) override final {
    26802691                assertf( false, "AttrExpr deprecated in new AST." );
    26812692        }
Note: See TracChangeset for help on using the changeset viewer.