Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    re67991f r1ae47de  
    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
    … …  
    10401039                                get<Expression>().accept1(node->expr),
    10411040                                inCache(node->deleteStmt) ?
    1042                                         strict_dynamic_cast<Declaration*>(this->node) :
    1043                                         get<Declaration>().accept1(node->deleteStmt)
     1041                                        this->node :
     1042                                        get<BaseSyntaxNode>().accept1(node->deleteStmt)
    10441043                        )
    10451044                );
    … …  
    13561355        ast::Node * node = nullptr;
    13571356        /// cache of nodes that might be referenced by readonly<> for de-duplication
    1358         std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
     1357        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
    13591358
    13601359        // Local Utilities:
    … …  
    14231422                to<std::vector>::from( make_labels( std::move( labels ) ) )
    14241423
    1425         static ast::CV::Qualifiers cv( const Type * ty ) { return { ty->tq.val }; }
     1424        static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
    14261425
    14271426        /// returns true and sets `node` if in cache
    1428         bool inCache( const BaseSyntaxNode * old ) {
     1427        bool inCache( BaseSyntaxNode * old ) {
    14291428                auto it = cache.find( old );
    14301429                if ( it == cache.end() ) return false;
    … …  
    14351434        // Now all the visit functions:
    14361435
    1437         virtual void visit( const ObjectDecl * old ) override final {
     1436        virtual void visit( ObjectDecl * old ) override final {
    14381437                auto&& type = GET_ACCEPT_1(type, Type);
    14391438                auto&& init = GET_ACCEPT_1(init, Init);
    … …  
    14661465        }
    14671466
    1468         virtual void visit( const FunctionDecl * old ) override final {
     1467        virtual void visit( FunctionDecl * old ) override final {
    14691468                if ( inCache( old ) ) return;
    14701469                auto decl = new ast::FunctionDecl{
    … …  
    14991498        }
    15001499
    1501         virtual void visit( const StructDecl * old ) override final {
     1500        virtual void visit( StructDecl * old ) override final {
    15021501                if ( inCache( old ) ) return;
    15031502                auto decl = new ast::StructDecl(
    … …  
    15241523        }
    15251524
    1526         virtual void visit( const UnionDecl * old ) override final {
     1525        virtual void visit( UnionDecl * old ) override final {
    15271526                if ( inCache( old ) ) return;
    15281527                auto decl = new ast::UnionDecl(
    … …  
    15441543        }
    15451544
    1546         virtual void visit( const EnumDecl * old ) override final {
     1545        virtual void visit( EnumDecl * old ) override final {
    15471546                if ( inCache( old ) ) return;
    15481547                auto decl = new ast::EnumDecl(
    … …  
    15641563        }
    15651564
    1566         virtual void visit( const TraitDecl * old ) override final {
     1565        virtual void visit( TraitDecl * old ) override final {
    15671566                if ( inCache( old ) ) return;
    15681567                auto decl = new ast::TraitDecl(
    … …  
    15841583        }
    15851584
    1586         virtual void visit( const TypeDecl * old ) override final {
     1585        virtual void visit( TypeDecl * old ) override final {
    15871586                if ( inCache( old ) ) return;
    15881587                auto decl = new ast::TypeDecl{
    … …  
    16041603        }
    16051604
    1606         virtual void visit( const TypedefDecl * old ) override final {
     1605        virtual void visit( TypedefDecl * old ) override final {
    16071606                auto decl = new ast::TypedefDecl(
    16081607                        old->location,
    … …  
    16211620        }
    16221621
    1623         virtual void visit( const AsmDecl * old ) override final {
     1622        virtual void visit( AsmDecl * old ) override final {
    16241623                auto decl = new ast::AsmDecl{
    16251624                        old->location,
    … …  
    16331632        }
    16341633
    1635         virtual void visit( const StaticAssertDecl * old ) override final {
     1634        virtual void visit( StaticAssertDecl * old ) override final {
    16361635                auto decl = new ast::StaticAssertDecl{
    16371636                        old->location,
    … …  
    16461645        }
    16471646
    1648         virtual void visit( const CompoundStmt * old ) override final {
     1647        virtual void visit( CompoundStmt * old ) override final {
    16491648                if ( inCache( old ) ) return;
    16501649                auto stmt = new ast::CompoundStmt(
    … …  
    16581657        }
    16591658
    1660         virtual void visit( const ExprStmt * old ) override final {
     1659        virtual void visit( ExprStmt * old ) override final {
    16611660                if ( inCache( old ) ) return;
    16621661                this->node = new ast::ExprStmt(
    … …  
    16681667        }
    16691668
    1670         virtual void visit( const AsmStmt * old ) override final {
     1669        virtual void visit( AsmStmt * old ) override final {
    16711670                if ( inCache( old ) ) return;
    16721671                this->node = new ast::AsmStmt(
    … …  
    16831682        }
    16841683
    1685         virtual void visit( const DirectiveStmt * old ) override final {
     1684        virtual void visit( DirectiveStmt * old ) override final {
    16861685                if ( inCache( old ) ) return;
    16871686                this->node = new ast::DirectiveStmt(
    … …  
    16931692        }
    16941693
    1695         virtual void visit( const IfStmt * old ) override final {
     1694        virtual void visit( IfStmt * old ) override final {
    16961695                if ( inCache( old ) ) return;
    16971696                this->node = new ast::IfStmt(
    … …  
    17061705        }
    17071706
    1708         virtual void visit( const SwitchStmt * old ) override final {
     1707        virtual void visit( SwitchStmt * old ) override final {
    17091708                if ( inCache( old ) ) return;
    17101709                this->node = new ast::SwitchStmt(
    … …  
    17171716        }
    17181717
    1719         virtual void visit( const CaseStmt * old ) override final {
     1718        virtual void visit( CaseStmt * old ) override final {
    17201719                if ( inCache( old ) ) return;
    17211720                this->node = new ast::CaseStmt(
    … …  
    17281727        }
    17291728
    1730         virtual void visit( const WhileStmt * old ) override final {
     1729        virtual void visit( WhileStmt * old ) override final {
    17311730                if ( inCache( old ) ) return;
    17321731                this->node = new ast::WhileStmt(
    … …  
    17411740        }
    17421741
    1743         virtual void visit( const ForStmt * old ) override final {
     1742        virtual void visit( ForStmt * old ) override final {
    17441743                if ( inCache( old ) ) return;
    17451744                this->node = new ast::ForStmt(
    … …  
    17541753        }
    17551754
    1756         virtual void visit( const BranchStmt * old ) override final {
     1755        virtual void visit( BranchStmt * old ) override final {
    17571756                if ( inCache( old ) ) return;
    17581757                if (old->computedTarget) {
    … …  
    17911790        }
    17921791
    1793         virtual void visit( const ReturnStmt * old ) override final {
     1792        virtual void visit( ReturnStmt * old ) override final {
    17941793                if ( inCache( old ) ) return;
    17951794                this->node = new ast::ReturnStmt(
    … …  
    18011800        }
    18021801
    1803         virtual void visit( const ThrowStmt * old ) override final {
     1802        virtual void visit( ThrowStmt * old ) override final {
    18041803                if ( inCache( old ) ) return;
    18051804                ast::ExceptionKind kind;
    … …  
    18251824        }
    18261825
    1827         virtual void visit( const TryStmt * old ) override final {
     1826        virtual void visit( TryStmt * old ) override final {
    18281827                if ( inCache( old ) ) return;
    18291828                this->node = new ast::TryStmt(
    … …  
    18371836        }
    18381837
    1839         virtual void visit( const CatchStmt * old ) override final {
     1838        virtual void visit( CatchStmt * old ) override final {
    18401839                if ( inCache( old ) ) return;
    18411840                ast::ExceptionKind kind;
    … …  
    18621861        }
    18631862
    1864         virtual void visit( const FinallyStmt * old ) override final {
     1863        virtual void visit( FinallyStmt * old ) override final {
    18651864                if ( inCache( old ) ) return;
    18661865                this->node = new ast::FinallyStmt(
    … …  
    18721871        }
    18731872
    1874         virtual void visit( const WaitForStmt * old ) override final {
     1873        virtual void visit( WaitForStmt * old ) override final {
    18751874                if ( inCache( old ) ) return;
    18761875                ast::WaitForStmt * stmt = new ast::WaitForStmt(
    … …  
    18961895                };
    18971896                stmt->orElse = {
    1898                         GET_ACCEPT_1(orelse.statement, Stmt),
    1899                         GET_ACCEPT_1(orelse.condition, Expr),
     1897                        GET_ACCEPT_1(timeout.statement, Stmt),
     1898                        GET_ACCEPT_1(timeout.condition, Expr),
    19001899                };
    19011900
    … …  
    19041903        }
    19051904
    1906         virtual void visit( const WithStmt * old ) override final {
     1905        virtual void visit( WithStmt * old ) override final {
    19071906                if ( inCache( old ) ) return;
    19081907                this->node = new ast::WithStmt(
    19091908                        old->location,
    19101909                        GET_ACCEPT_V(exprs, Expr),
    1911                         GET_ACCEPT_1(stmt, Stmt)
     1910                        GET_ACCEPT_1(stmt, Stmt),
     1911                        GET_LABELS_V(old->labels)
    19121912                );
    19131913                cache.emplace( old, this->node );
    19141914        }
    19151915
    1916         virtual void visit( const NullStmt * old ) override final {
     1916        virtual void visit( NullStmt * old ) override final {
    19171917                if ( inCache( old ) ) return;
    19181918                this->node = new ast::NullStmt(
    … …  
    19231923        }
    19241924
    1925         virtual void visit( const DeclStmt * old ) override final {
     1925        virtual void visit( DeclStmt * old ) override final {
    19261926                if ( inCache( old ) ) return;
    19271927                this->node = new ast::DeclStmt(
    … …  
    19331933        }
    19341934
    1935         virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
     1935        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
    19361936                if ( inCache( old ) ) return;
    19371937                auto stmt = new ast::ImplicitCtorDtorStmt(
    … …  
    19901990        }
    19911991
    1992         ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
     1992        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
    19931993
    19941994                nw->env    = convertTypeSubstitution(old->env);
    … …  
    20002000        }
    20012001
    2002         ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
     2002        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
    20032003
    20042004                nw->result = GET_ACCEPT_1(result, Type);
    … …  
    20062006        }
    20072007
    2008         virtual void visit( const ApplicationExpr * old ) override final {
     2008        virtual void visit( ApplicationExpr * old ) override final {
    20092009                this->node = visitBaseExpr( old,
    20102010                        new ast::ApplicationExpr(
    … …  
    20162016        }
    20172017
    2018         virtual void visit( const UntypedExpr * old ) override final {
     2018        virtual void visit( UntypedExpr * old ) override final {
    20192019                this->node = visitBaseExpr( old,
    20202020                        new ast::UntypedExpr(
    … …  
    20262026        }
    20272027
    2028         virtual void visit( const NameExpr * old ) override final {
     2028        virtual void visit( NameExpr * old ) override final {
    20292029                this->node = visitBaseExpr( old,
    20302030                        new ast::NameExpr(
    … …  
    20352035        }
    20362036
    2037         virtual void visit( const CastExpr * old ) override final {
     2037        virtual void visit( CastExpr * old ) override final {
    20382038                this->node = visitBaseExpr( old,
    20392039                        new ast::CastExpr(
    … …  
    20452045        }
    20462046
    2047         virtual void visit( const KeywordCastExpr * old) override final {
     2047        virtual void visit( KeywordCastExpr * old) override final {
    20482048                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    20492049                switch (old->target) {
    … …  
    20702070        }
    20712071
    2072         virtual void visit( const VirtualCastExpr * old ) override final {
     2072        virtual void visit( VirtualCastExpr * old ) override final {
    20732073                this->node = visitBaseExpr_SkipResultType( old,
    20742074                        new ast::VirtualCastExpr(
    … …  
    20802080        }
    20812081
    2082         virtual void visit( const AddressExpr * old ) override final {
     2082        virtual void visit( AddressExpr * old ) override final {
    20832083                this->node = visitBaseExpr( old,
    20842084                        new ast::AddressExpr(
    … …  
    20892089        }
    20902090
    2091         virtual void visit( const LabelAddressExpr * old ) override final {
     2091        virtual void visit( LabelAddressExpr * old ) override final {
    20922092                this->node = visitBaseExpr( old,
    20932093                        new ast::LabelAddressExpr(
    … …  
    20982098        }
    20992099
    2100         virtual void visit( const UntypedMemberExpr * old ) override final {
     2100        virtual void visit( UntypedMemberExpr * old ) override final {
    21012101                this->node = visitBaseExpr( old,
    21022102                        new ast::UntypedMemberExpr(
    … …  
    21082108        }
    21092109
    2110         virtual void visit( const MemberExpr * old ) override final {
     2110        virtual void visit( MemberExpr * old ) override final {
    21112111                this->node = visitBaseExpr( old,
    21122112                        new ast::MemberExpr(
    … …  
    21182118        }
    21192119
    2120         virtual void visit( const VariableExpr * old ) override final {
     2120        virtual void visit( VariableExpr * old ) override final {
    21212121                auto expr = new ast::VariableExpr(
    21222122                        old->location
    … …  
    21292129        }
    21302130
    2131         virtual void visit( const ConstantExpr * old ) override final {
     2131        virtual void visit( ConstantExpr * old ) override final {
    21322132                ast::ConstantExpr *rslt = new ast::ConstantExpr(
    21332133                        old->location,
    21342134                        GET_ACCEPT_1(result, Type),
    2135                         old->constant.rep,
     2135                        old->constant.get_value(),
    21362136                        old->constant.ival
    21372137                );
    2138                 rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
     2138                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
    21392139                this->node = visitBaseExpr( old, rslt );
    21402140        }
    21412141
    2142         virtual void visit( const SizeofExpr * old ) override final {
     2142        virtual void visit( SizeofExpr * old ) override final {
    21432143                assert (old->expr || old->type);
    21442144                assert (! (old->expr && old->type));
    … …  
    21612161        }
    21622162
    2163         virtual void visit( const AlignofExpr * old ) override final {
     2163        virtual void visit( AlignofExpr * old ) override final {
    21642164                assert (old->expr || old->type);
    21652165                assert (! (old->expr && old->type));
    … …  
    21822182        }
    21832183
    2184         virtual void visit( const UntypedOffsetofExpr * old ) override final {
     2184        virtual void visit( UntypedOffsetofExpr * old ) override final {
    21852185                this->node = visitBaseExpr( old,
    21862186                        new ast::UntypedOffsetofExpr(
    … …  
    21922192        }
    21932193
    2194         virtual void visit( const OffsetofExpr * old ) override final {
     2194        virtual void visit( OffsetofExpr * old ) override final {
    21952195                this->node = visitBaseExpr( old,
    21962196                        new ast::OffsetofExpr(
    … …  
    22022202        }
    22032203
    2204         virtual void visit( const OffsetPackExpr * old ) override final {
     2204        virtual void visit( OffsetPackExpr * old ) override final {
    22052205                this->node = visitBaseExpr( old,
    22062206                        new ast::OffsetPackExpr(
    … …  
    22112211        }
    22122212
    2213         virtual void visit( const LogicalExpr * old ) override final {
     2213        virtual void visit( LogicalExpr * old ) override final {
    22142214                this->node = visitBaseExpr( old,
    22152215                        new ast::LogicalExpr(
    … …  
    22242224        }
    22252225
    2226         virtual void visit( const ConditionalExpr * old ) override final {
     2226        virtual void visit( ConditionalExpr * old ) override final {
    22272227                this->node = visitBaseExpr( old,
    22282228                        new ast::ConditionalExpr(
    … …  
    22352235        }
    22362236
    2237         virtual void visit( const CommaExpr * old ) override final {
     2237        virtual void visit( CommaExpr * old ) override final {
    22382238                this->node = visitBaseExpr( old,
    22392239                        new ast::CommaExpr(
    … …  
    22452245        }
    22462246
    2247         virtual void visit( const TypeExpr * old ) override final {
     2247        virtual void visit( TypeExpr * old ) override final {
    22482248                this->node = visitBaseExpr( old,
    22492249                        new ast::TypeExpr(
    … …  
    22542254        }
    22552255
    2256         virtual void visit( const AsmExpr * old ) override final {
     2256        virtual void visit( AsmExpr * old ) override final {
    22572257                this->node = visitBaseExpr( old,
    22582258                        new ast::AsmExpr(
    … …  
    22652265        }
    22662266
    2267         virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
     2267        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
    22682268                auto rslt = new ast::ImplicitCopyCtorExpr(
    22692269                        old->location,
    … …  
    22742274        }
    22752275
    2276         virtual void visit( const ConstructorExpr * old ) override final {
     2276        virtual void visit( ConstructorExpr * old ) override final {
    22772277                this->node = visitBaseExpr( old,
    22782278                        new ast::ConstructorExpr(
    … …  
    22832283        }
    22842284
    2285         virtual void visit( const CompoundLiteralExpr * old ) override final {
     2285        virtual void visit( CompoundLiteralExpr * old ) override final {
    22862286                this->node = visitBaseExpr_SkipResultType( old,
    22872287                        new ast::CompoundLiteralExpr(
    … …  
    22932293        }
    22942294
    2295         virtual void visit( const RangeExpr * old ) override final {
     2295        virtual void visit( RangeExpr * old ) override final {
    22962296                this->node = visitBaseExpr( old,
    22972297                        new ast::RangeExpr(
    … …  
    23032303        }
    23042304
    2305         virtual void visit( const UntypedTupleExpr * old ) override final {
     2305        virtual void visit( UntypedTupleExpr * old ) override final {
    23062306                this->node = visitBaseExpr( old,
    23072307                        new ast::UntypedTupleExpr(
    … …  
    23122312        }
    23132313
    2314         virtual void visit( const TupleExpr * old ) override final {
     2314        virtual void visit( TupleExpr * old ) override final {
    23152315                this->node = visitBaseExpr( old,
    23162316                        new ast::TupleExpr(
    … …  
    23212321        }
    23222322
    2323         virtual void visit( const TupleIndexExpr * old ) override final {
     2323        virtual void visit( TupleIndexExpr * old ) override final {
    23242324                this->node = visitBaseExpr( old,
    23252325                        new ast::TupleIndexExpr(
    … …  
    23312331        }
    23322332
    2333         virtual void visit( const TupleAssignExpr * old ) override final {
     2333        virtual void visit( TupleAssignExpr * old ) override final {
    23342334                this->node = visitBaseExpr_SkipResultType( old,
    23352335                        new ast::TupleAssignExpr(
    … …  
    23412341        }
    23422342
    2343         virtual void visit( const StmtExpr * old ) override final {
     2343        virtual void visit( StmtExpr * old ) override final {
    23442344                auto rslt = new ast::StmtExpr(
    23452345                        old->location,
    … …  
    23522352        }
    23532353
    2354         virtual void visit( const UniqueExpr * old ) override final {
     2354        virtual void visit( UniqueExpr * old ) override final {
    23552355                auto rslt = new ast::UniqueExpr(
    23562356                        old->location,
    … …  
    23642364        }
    23652365
    2366         virtual void visit( const UntypedInitExpr * old ) override final {
     2366        virtual void visit( UntypedInitExpr * old ) override final {
    23672367                std::deque<ast::InitAlternative> initAlts;
    23682368                for (auto ia : old->initAlts) {
    … …  
    23812381        }
    23822382
    2383         virtual void visit( const InitExpr * old ) override final {
     2383        virtual void visit( InitExpr * old ) override final {
    23842384                this->node = visitBaseExpr( old,
    23852385                        new ast::InitExpr(
    … …  
    23912391        }
    23922392
    2393         virtual void visit( const DeletedExpr * old ) override final {
     2393        virtual void visit( DeletedExpr * old ) override final {
    23942394                this->node = visitBaseExpr( old,
    23952395                        new ast::DeletedExpr(
    … …  
    23972397                                GET_ACCEPT_1(expr, Expr),
    23982398                                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 {
     2399                                        this->node :
     2400                                        GET_ACCEPT_1(deleteStmt, Node)
     2401                        )
     2402                );
     2403        }
     2404
     2405        virtual void visit( DefaultArgExpr * old ) override final {
    24062406                this->node = visitBaseExpr( old,
    24072407                        new ast::DefaultArgExpr(
    … …  
    24122412        }
    24132413
    2414         virtual void visit( const GenericExpr * old ) override final {
     2414        virtual void visit( GenericExpr * old ) override final {
    24152415                std::vector<ast::GenericExpr::Association> associations;
    24162416                for (auto association : old->associations) {
    … …  
    24292429        }
    24302430
    2431         void visitType( const Type * old, ast::Type * type ) {
     2431        void visitType( Type * old, ast::Type * type ) {
    24322432                // Some types do this in their constructor so add a check.
    24332433                if ( !old->attributes.empty() && type->attributes.empty() ) {
    … …  
    24372437        }
    24382438
    2439         virtual void visit( const VoidType * old ) override final {
     2439        virtual void visit( VoidType * old ) override final {
    24402440                visitType( old, new ast::VoidType{ cv( old ) } );
    24412441        }
    24422442
    2443         virtual void visit( const BasicType * old ) override final {
     2443        virtual void visit( BasicType * old ) override final {
    24442444                auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
    24452445                // I believe this should always be a BasicType.
    … …  
    24502450        }
    24512451
    2452         virtual void visit( const PointerType * old ) override final {
     2452        virtual void visit( PointerType * old ) override final {
    24532453                visitType( old, new ast::PointerType{
    24542454                        GET_ACCEPT_1( base, Type ),
    … …  
    24602460        }
    24612461
    2462         virtual void visit( const ArrayType * old ) override final {
     2462        virtual void visit( ArrayType * old ) override final {
    24632463                visitType( old, new ast::ArrayType{
    24642464                        GET_ACCEPT_1( base, Type ),
    … …  
    24702470        }
    24712471
    2472         virtual void visit( const ReferenceType * old ) override final {
     2472        virtual void visit( ReferenceType * old ) override final {
    24732473                visitType( old, new ast::ReferenceType{
    24742474                        GET_ACCEPT_1( base, Type ),
    … …  
    24772477        }
    24782478
    2479         virtual void visit( const QualifiedType * old ) override final {
     2479        virtual void visit( QualifiedType * old ) override final {
    24802480                visitType( old, new ast::QualifiedType{
    24812481                        GET_ACCEPT_1( parent, Type ),
    … …  
    24852485        }
    24862486
    2487         virtual void visit( const FunctionType * old ) override final {
     2487        virtual void visit( FunctionType * old ) override final {
    24882488                auto ty = new ast::FunctionType {
    24892489                        (ast::ArgumentFlag)old->isVarArgs,
    … …  
    24962496        }
    24972497
    2498         void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
     2498        void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
    24992499                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
    25002500                ty->params = GET_ACCEPT_V( parameters, Expr );
    … …  
    25032503        }
    25042504
    2505         virtual void visit( const StructInstType * old ) override final {
     2505        virtual void visit( StructInstType * old ) override final {
    25062506                ast::StructInstType * ty;
    25072507                if ( old->baseStruct ) {
    … …  
    25212521        }
    25222522
    2523         virtual void visit( const UnionInstType * old ) override final {
     2523        virtual void visit( UnionInstType * old ) override final {
    25242524                ast::UnionInstType * ty;
    25252525                if ( old->baseUnion ) {
    … …  
    25392539        }
    25402540
    2541         virtual void visit( const EnumInstType * old ) override final {
     2541        virtual void visit( EnumInstType * old ) override final {
    25422542                ast::EnumInstType * ty;
    25432543                if ( old->baseEnum ) {
    … …  
    25572557        }
    25582558
    2559         virtual void visit( const TraitInstType * old ) override final {
     2559        virtual void visit( TraitInstType * old ) override final {
    25602560                ast::TraitInstType * ty;
    25612561                if ( old->baseTrait ) {
    … …  
    25752575        }
    25762576
    2577         virtual void visit( const TypeInstType * old ) override final {
     2577        virtual void visit( TypeInstType * old ) override final {
    25782578                ast::TypeInstType * ty;
    25792579                if ( old->baseType ) {
    … …  
    25952595        }
    25962596
    2597         virtual void visit( const TupleType * old ) override final {
     2597        virtual void visit( TupleType * old ) override final {
    25982598                visitType( old, new ast::TupleType{
    25992599                        GET_ACCEPT_V( types, Type ),
    … …  
    26032603        }
    26042604
    2605         virtual void visit( const TypeofType * old ) override final {
     2605        virtual void visit( TypeofType * old ) override final {
    26062606                visitType( old, new ast::TypeofType{
    26072607                        GET_ACCEPT_1( expr, Expr ),
    … …  
    26112611        }
    26122612
    2613         virtual void visit( const AttrType * ) override final {
     2613        virtual void visit( AttrType * ) override final {
    26142614                assertf( false, "AttrType deprecated in new AST." );
    26152615        }
    26162616
    2617         virtual void visit( const VarArgsType * old ) override final {
     2617        virtual void visit( VarArgsType * old ) override final {
    26182618                visitType( old, new ast::VarArgsType{ cv( old ) } );
    26192619        }
    26202620
    2621         virtual void visit( const ZeroType * old ) override final {
     2621        virtual void visit( ZeroType * old ) override final {
    26222622                visitType( old, new ast::ZeroType{ cv( old ) } );
    26232623        }
    26242624
    2625         virtual void visit( const OneType * old ) override final {
     2625        virtual void visit( OneType * old ) override final {
    26262626                visitType( old, new ast::OneType{ cv( old ) } );
    26272627        }
    26282628
    2629         virtual void visit( const GlobalScopeType * old ) override final {
     2629        virtual void visit( GlobalScopeType * old ) override final {
    26302630                visitType( old, new ast::GlobalScopeType{} );
    26312631        }
    26322632
    2633         virtual void visit( const Designation * old ) override final {
     2633        virtual void visit( Designation * old ) override final {
    26342634                this->node = new ast::Designation(
    26352635                        old->location,
    … …  
    26382638        }
    26392639
    2640         virtual void visit( const SingleInit * old ) override final {
     2640        virtual void visit( SingleInit * old ) override final {
    26412641                this->node = new ast::SingleInit(
    26422642                        old->location,
    … …  
    26462646        }
    26472647
    2648         virtual void visit( const ListInit * old ) override final {
     2648        virtual void visit( ListInit * old ) override final {
    26492649                this->node = new ast::ListInit(
    26502650                        old->location,
    … …  
    26552655        }
    26562656
    2657         virtual void visit( const ConstructorInit * old ) override final {
     2657        virtual void visit( ConstructorInit * old ) override final {
    26582658                this->node = new ast::ConstructorInit(
    26592659                        old->location,
    … …  
    26642664        }
    26652665
    2666         virtual void visit( const Constant * ) override final {
     2666        virtual void visit( Constant * ) override final {
    26672667                // Handled in visit( ConstantEpxr * ).
    26682668                // In the new tree, Constant fields are inlined into containing ConstantExpression.
    … …  
    26702670        }
    26712671
    2672         virtual void visit( const Attribute * old ) override final {
     2672        virtual void visit( Attribute * old ) override final {
    26732673                this->node = new ast::Attribute(
    26742674                        old->name,
    … …  
    26772677        }
    26782678
    2679         virtual void visit( const AttrExpr * ) override final {
     2679        virtual void visit( AttrExpr * ) override final {
    26802680                assertf( false, "AttrExpr deprecated in new AST." );
    26812681        }
Note: See TracChangeset for help on using the changeset viewer.