Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    rf6cc734e re67991f  
    518518        }
    519519
    520         const ast::Stmt * visit( const ast::WithStmt * node ) override final {
     520        const ast::Decl * 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                 return stmtPostamble( stmt, node );
     526                declPostamble( stmt, node );
     527                return nullptr;
    527528        }
    528529
    … …  
    607608
    608609                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                 }
    620610                return visitBaseExpr_skipResultType(src, tgt);
    621611        }
    … …  
    10501040                                get<Expression>().accept1(node->expr),
    10511041                                inCache(node->deleteStmt) ?
    1052                                         this->node :
    1053                                         get<BaseSyntaxNode>().accept1(node->deleteStmt)
     1042                                        strict_dynamic_cast<Declaration*>(this->node) :
     1043                                        get<Declaration>().accept1(node->deleteStmt)
    10541044                        )
    10551045                );
    … …  
    13661356        ast::Node * node = nullptr;
    13671357        /// cache of nodes that might be referenced by readonly<> for de-duplication
    1368         std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
     1358        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
    13691359
    13701360        // Local Utilities:
    … …  
    14331423                to<std::vector>::from( make_labels( std::move( labels ) ) )
    14341424
    1435         static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
     1425        static ast::CV::Qualifiers cv( const Type * ty ) { return { ty->tq.val }; }
    14361426
    14371427        /// returns true and sets `node` if in cache
    1438         bool inCache( BaseSyntaxNode * old ) {
     1428        bool inCache( const BaseSyntaxNode * old ) {
    14391429                auto it = cache.find( old );
    14401430                if ( it == cache.end() ) return false;
    … …  
    14451435        // Now all the visit functions:
    14461436
    1447         virtual void visit( ObjectDecl * old ) override final {
     1437        virtual void visit( const ObjectDecl * old ) override final {
    14481438                auto&& type = GET_ACCEPT_1(type, Type);
    14491439                auto&& init = GET_ACCEPT_1(init, Init);
    … …  
    14761466        }
    14771467
    1478         virtual void visit( FunctionDecl * old ) override final {
     1468        virtual void visit( const FunctionDecl * old ) override final {
    14791469                if ( inCache( old ) ) return;
    14801470                auto decl = new ast::FunctionDecl{
    … …  
    15091499        }
    15101500
    1511         virtual void visit( StructDecl * old ) override final {
     1501        virtual void visit( const StructDecl * old ) override final {
    15121502                if ( inCache( old ) ) return;
    15131503                auto decl = new ast::StructDecl(
    … …  
    15341524        }
    15351525
    1536         virtual void visit( UnionDecl * old ) override final {
     1526        virtual void visit( const UnionDecl * old ) override final {
    15371527                if ( inCache( old ) ) return;
    15381528                auto decl = new ast::UnionDecl(
    … …  
    15541544        }
    15551545
    1556         virtual void visit( EnumDecl * old ) override final {
     1546        virtual void visit( const EnumDecl * old ) override final {
    15571547                if ( inCache( old ) ) return;
    15581548                auto decl = new ast::EnumDecl(
    … …  
    15741564        }
    15751565
    1576         virtual void visit( TraitDecl * old ) override final {
     1566        virtual void visit( const TraitDecl * old ) override final {
    15771567                if ( inCache( old ) ) return;
    15781568                auto decl = new ast::TraitDecl(
    … …  
    15941584        }
    15951585
    1596         virtual void visit( TypeDecl * old ) override final {
     1586        virtual void visit( const TypeDecl * old ) override final {
    15971587                if ( inCache( old ) ) return;
    15981588                auto decl = new ast::TypeDecl{
    … …  
    16141604        }
    16151605
    1616         virtual void visit( TypedefDecl * old ) override final {
     1606        virtual void visit( const TypedefDecl * old ) override final {
    16171607                auto decl = new ast::TypedefDecl(
    16181608                        old->location,
    … …  
    16311621        }
    16321622
    1633         virtual void visit( AsmDecl * old ) override final {
     1623        virtual void visit( const AsmDecl * old ) override final {
    16341624                auto decl = new ast::AsmDecl{
    16351625                        old->location,
    … …  
    16431633        }
    16441634
    1645         virtual void visit( StaticAssertDecl * old ) override final {
     1635        virtual void visit( const StaticAssertDecl * old ) override final {
    16461636                auto decl = new ast::StaticAssertDecl{
    16471637                        old->location,
    … …  
    16561646        }
    16571647
    1658         virtual void visit( CompoundStmt * old ) override final {
     1648        virtual void visit( const CompoundStmt * old ) override final {
    16591649                if ( inCache( old ) ) return;
    16601650                auto stmt = new ast::CompoundStmt(
    … …  
    16681658        }
    16691659
    1670         virtual void visit( ExprStmt * old ) override final {
     1660        virtual void visit( const ExprStmt * old ) override final {
    16711661                if ( inCache( old ) ) return;
    16721662                this->node = new ast::ExprStmt(
    … …  
    16781668        }
    16791669
    1680         virtual void visit( AsmStmt * old ) override final {
     1670        virtual void visit( const AsmStmt * old ) override final {
    16811671                if ( inCache( old ) ) return;
    16821672                this->node = new ast::AsmStmt(
    … …  
    16931683        }
    16941684
    1695         virtual void visit( DirectiveStmt * old ) override final {
     1685        virtual void visit( const DirectiveStmt * old ) override final {
    16961686                if ( inCache( old ) ) return;
    16971687                this->node = new ast::DirectiveStmt(
    … …  
    17031693        }
    17041694
    1705         virtual void visit( IfStmt * old ) override final {
     1695        virtual void visit( const IfStmt * old ) override final {
    17061696                if ( inCache( old ) ) return;
    17071697                this->node = new ast::IfStmt(
    … …  
    17161706        }
    17171707
    1718         virtual void visit( SwitchStmt * old ) override final {
     1708        virtual void visit( const SwitchStmt * old ) override final {
    17191709                if ( inCache( old ) ) return;
    17201710                this->node = new ast::SwitchStmt(
    … …  
    17271717        }
    17281718
    1729         virtual void visit( CaseStmt * old ) override final {
     1719        virtual void visit( const CaseStmt * old ) override final {
    17301720                if ( inCache( old ) ) return;
    17311721                this->node = new ast::CaseStmt(
    … …  
    17381728        }
    17391729
    1740         virtual void visit( WhileStmt * old ) override final {
     1730        virtual void visit( const WhileStmt * old ) override final {
    17411731                if ( inCache( old ) ) return;
    17421732                this->node = new ast::WhileStmt(
    … …  
    17511741        }
    17521742
    1753         virtual void visit( ForStmt * old ) override final {
     1743        virtual void visit( const ForStmt * old ) override final {
    17541744                if ( inCache( old ) ) return;
    17551745                this->node = new ast::ForStmt(
    … …  
    17641754        }
    17651755
    1766         virtual void visit( BranchStmt * old ) override final {
     1756        virtual void visit( const BranchStmt * old ) override final {
    17671757                if ( inCache( old ) ) return;
    17681758                if (old->computedTarget) {
    … …  
    18011791        }
    18021792
    1803         virtual void visit( ReturnStmt * old ) override final {
     1793        virtual void visit( const ReturnStmt * old ) override final {
    18041794                if ( inCache( old ) ) return;
    18051795                this->node = new ast::ReturnStmt(
    … …  
    18111801        }
    18121802
    1813         virtual void visit( ThrowStmt * old ) override final {
     1803        virtual void visit( const ThrowStmt * old ) override final {
    18141804                if ( inCache( old ) ) return;
    18151805                ast::ExceptionKind kind;
    … …  
    18351825        }
    18361826
    1837         virtual void visit( TryStmt * old ) override final {
     1827        virtual void visit( const TryStmt * old ) override final {
    18381828                if ( inCache( old ) ) return;
    18391829                this->node = new ast::TryStmt(
    … …  
    18471837        }
    18481838
    1849         virtual void visit( CatchStmt * old ) override final {
     1839        virtual void visit( const CatchStmt * old ) override final {
    18501840                if ( inCache( old ) ) return;
    18511841                ast::ExceptionKind kind;
    … …  
    18721862        }
    18731863
    1874         virtual void visit( FinallyStmt * old ) override final {
     1864        virtual void visit( const FinallyStmt * old ) override final {
    18751865                if ( inCache( old ) ) return;
    18761866                this->node = new ast::FinallyStmt(
    … …  
    18821872        }
    18831873
    1884         virtual void visit( WaitForStmt * old ) override final {
     1874        virtual void visit( const WaitForStmt * old ) override final {
    18851875                if ( inCache( old ) ) return;
    18861876                ast::WaitForStmt * stmt = new ast::WaitForStmt(
    … …  
    19141904        }
    19151905
    1916         virtual void visit( WithStmt * old ) override final {
     1906        virtual void visit( const WithStmt * old ) override final {
    19171907                if ( inCache( old ) ) return;
    19181908                this->node = new ast::WithStmt(
    19191909                        old->location,
    19201910                        GET_ACCEPT_V(exprs, Expr),
    1921                         GET_ACCEPT_1(stmt, Stmt),
    1922                         GET_LABELS_V(old->labels)
     1911                        GET_ACCEPT_1(stmt, Stmt)
    19231912                );
    19241913                cache.emplace( old, this->node );
    19251914        }
    19261915
    1927         virtual void visit( NullStmt * old ) override final {
     1916        virtual void visit( const NullStmt * old ) override final {
    19281917                if ( inCache( old ) ) return;
    19291918                this->node = new ast::NullStmt(
    … …  
    19341923        }
    19351924
    1936         virtual void visit( DeclStmt * old ) override final {
     1925        virtual void visit( const DeclStmt * old ) override final {
    19371926                if ( inCache( old ) ) return;
    19381927                this->node = new ast::DeclStmt(
    … …  
    19441933        }
    19451934
    1946         virtual void visit( ImplicitCtorDtorStmt * old ) override final {
     1935        virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
    19471936                if ( inCache( old ) ) return;
    19481937                auto stmt = new ast::ImplicitCtorDtorStmt(
    … …  
    20011990        }
    20021991
    2003         ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
     1992        ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
    20041993
    20051994                nw->env    = convertTypeSubstitution(old->env);
    … …  
    20112000        }
    20122001
    2013         ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
     2002        ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
    20142003
    20152004                nw->result = GET_ACCEPT_1(result, Type);
    … …  
    20172006        }
    20182007
    2019         virtual void visit( ApplicationExpr * old ) override final {
     2008        virtual void visit( const ApplicationExpr * old ) override final {
    20202009                this->node = visitBaseExpr( old,
    20212010                        new ast::ApplicationExpr(
    … …  
    20272016        }
    20282017
    2029         virtual void visit( UntypedExpr * old ) override final {
     2018        virtual void visit( const UntypedExpr * old ) override final {
    20302019                this->node = visitBaseExpr( old,
    20312020                        new ast::UntypedExpr(
    … …  
    20372026        }
    20382027
    2039         virtual void visit( NameExpr * old ) override final {
     2028        virtual void visit( const NameExpr * old ) override final {
    20402029                this->node = visitBaseExpr( old,
    20412030                        new ast::NameExpr(
    … …  
    20462035        }
    20472036
    2048         virtual void visit( CastExpr * old ) override final {
     2037        virtual void visit( const CastExpr * old ) override final {
    20492038                this->node = visitBaseExpr( old,
    20502039                        new ast::CastExpr(
    … …  
    20562045        }
    20572046
    2058         virtual void visit( KeywordCastExpr * old) override final {
     2047        virtual void visit( const KeywordCastExpr * old) override final {
    20592048                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    20602049                switch (old->target) {
    … …  
    20812070        }
    20822071
    2083         virtual void visit( VirtualCastExpr * old ) override final {
     2072        virtual void visit( const VirtualCastExpr * old ) override final {
    20842073                this->node = visitBaseExpr_SkipResultType( old,
    20852074                        new ast::VirtualCastExpr(
    … …  
    20912080        }
    20922081
    2093         virtual void visit( AddressExpr * old ) override final {
     2082        virtual void visit( const AddressExpr * old ) override final {
    20942083                this->node = visitBaseExpr( old,
    20952084                        new ast::AddressExpr(
    … …  
    21002089        }
    21012090
    2102         virtual void visit( LabelAddressExpr * old ) override final {
     2091        virtual void visit( const LabelAddressExpr * old ) override final {
    21032092                this->node = visitBaseExpr( old,
    21042093                        new ast::LabelAddressExpr(
    … …  
    21092098        }
    21102099
    2111         virtual void visit( UntypedMemberExpr * old ) override final {
     2100        virtual void visit( const UntypedMemberExpr * old ) override final {
    21122101                this->node = visitBaseExpr( old,
    21132102                        new ast::UntypedMemberExpr(
    … …  
    21192108        }
    21202109
    2121         virtual void visit( MemberExpr * old ) override final {
     2110        virtual void visit( const MemberExpr * old ) override final {
    21222111                this->node = visitBaseExpr( old,
    21232112                        new ast::MemberExpr(
    … …  
    21292118        }
    21302119
    2131         virtual void visit( VariableExpr * old ) override final {
     2120        virtual void visit( const VariableExpr * old ) override final {
    21322121                auto expr = new ast::VariableExpr(
    21332122                        old->location
    … …  
    21402129        }
    21412130
    2142         virtual void visit( ConstantExpr * old ) override final {
     2131        virtual void visit( const ConstantExpr * old ) override final {
    21432132                ast::ConstantExpr *rslt = new ast::ConstantExpr(
    21442133                        old->location,
    21452134                        GET_ACCEPT_1(result, Type),
    2146                         old->constant.get_value(),
     2135                        old->constant.rep,
    21472136                        old->constant.ival
    21482137                );
    2149                 rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
     2138                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
    21502139                this->node = visitBaseExpr( old, rslt );
    21512140        }
    21522141
    2153         virtual void visit( SizeofExpr * old ) override final {
     2142        virtual void visit( const SizeofExpr * old ) override final {
    21542143                assert (old->expr || old->type);
    21552144                assert (! (old->expr && old->type));
    … …  
    21722161        }
    21732162
    2174         virtual void visit( AlignofExpr * old ) override final {
     2163        virtual void visit( const AlignofExpr * old ) override final {
    21752164                assert (old->expr || old->type);
    21762165                assert (! (old->expr && old->type));
    … …  
    21932182        }
    21942183
    2195         virtual void visit( UntypedOffsetofExpr * old ) override final {
     2184        virtual void visit( const UntypedOffsetofExpr * old ) override final {
    21962185                this->node = visitBaseExpr( old,
    21972186                        new ast::UntypedOffsetofExpr(
    … …  
    22032192        }
    22042193
    2205         virtual void visit( OffsetofExpr * old ) override final {
     2194        virtual void visit( const OffsetofExpr * old ) override final {
    22062195                this->node = visitBaseExpr( old,
    22072196                        new ast::OffsetofExpr(
    … …  
    22132202        }
    22142203
    2215         virtual void visit( OffsetPackExpr * old ) override final {
     2204        virtual void visit( const OffsetPackExpr * old ) override final {
    22162205                this->node = visitBaseExpr( old,
    22172206                        new ast::OffsetPackExpr(
    … …  
    22222211        }
    22232212
    2224         virtual void visit( LogicalExpr * old ) override final {
     2213        virtual void visit( const LogicalExpr * old ) override final {
    22252214                this->node = visitBaseExpr( old,
    22262215                        new ast::LogicalExpr(
    … …  
    22352224        }
    22362225
    2237         virtual void visit( ConditionalExpr * old ) override final {
     2226        virtual void visit( const ConditionalExpr * old ) override final {
    22382227                this->node = visitBaseExpr( old,
    22392228                        new ast::ConditionalExpr(
    … …  
    22462235        }
    22472236
    2248         virtual void visit( CommaExpr * old ) override final {
     2237        virtual void visit( const CommaExpr * old ) override final {
    22492238                this->node = visitBaseExpr( old,
    22502239                        new ast::CommaExpr(
    … …  
    22562245        }
    22572246
    2258         virtual void visit( TypeExpr * old ) override final {
     2247        virtual void visit( const TypeExpr * old ) override final {
    22592248                this->node = visitBaseExpr( old,
    22602249                        new ast::TypeExpr(
    … …  
    22652254        }
    22662255
    2267         virtual void visit( AsmExpr * old ) override final {
     2256        virtual void visit( const AsmExpr * old ) override final {
    22682257                this->node = visitBaseExpr( old,
    22692258                        new ast::AsmExpr(
    … …  
    22762265        }
    22772266
    2278         virtual void visit( ImplicitCopyCtorExpr * old ) override final {
     2267        virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
    22792268                auto rslt = new ast::ImplicitCopyCtorExpr(
    22802269                        old->location,
    … …  
    22852274        }
    22862275
    2287         virtual void visit( ConstructorExpr * old ) override final {
     2276        virtual void visit( const ConstructorExpr * old ) override final {
    22882277                this->node = visitBaseExpr( old,
    22892278                        new ast::ConstructorExpr(
    … …  
    22942283        }
    22952284
    2296         virtual void visit( CompoundLiteralExpr * old ) override final {
     2285        virtual void visit( const CompoundLiteralExpr * old ) override final {
    22972286                this->node = visitBaseExpr_SkipResultType( old,
    22982287                        new ast::CompoundLiteralExpr(
    … …  
    23042293        }
    23052294
    2306         virtual void visit( RangeExpr * old ) override final {
     2295        virtual void visit( const RangeExpr * old ) override final {
    23072296                this->node = visitBaseExpr( old,
    23082297                        new ast::RangeExpr(
    … …  
    23142303        }
    23152304
    2316         virtual void visit( UntypedTupleExpr * old ) override final {
     2305        virtual void visit( const UntypedTupleExpr * old ) override final {
    23172306                this->node = visitBaseExpr( old,
    23182307                        new ast::UntypedTupleExpr(
    … …  
    23232312        }
    23242313
    2325         virtual void visit( TupleExpr * old ) override final {
     2314        virtual void visit( const TupleExpr * old ) override final {
    23262315                this->node = visitBaseExpr( old,
    23272316                        new ast::TupleExpr(
    … …  
    23322321        }
    23332322
    2334         virtual void visit( TupleIndexExpr * old ) override final {
     2323        virtual void visit( const TupleIndexExpr * old ) override final {
    23352324                this->node = visitBaseExpr( old,
    23362325                        new ast::TupleIndexExpr(
    … …  
    23422331        }
    23432332
    2344         virtual void visit( TupleAssignExpr * old ) override final {
     2333        virtual void visit( const TupleAssignExpr * old ) override final {
    23452334                this->node = visitBaseExpr_SkipResultType( old,
    23462335                        new ast::TupleAssignExpr(
    … …  
    23522341        }
    23532342
    2354         virtual void visit( StmtExpr * old ) override final {
     2343        virtual void visit( const StmtExpr * old ) override final {
    23552344                auto rslt = new ast::StmtExpr(
    23562345                        old->location,
    … …  
    23632352        }
    23642353
    2365         virtual void visit( UniqueExpr * old ) override final {
     2354        virtual void visit( const UniqueExpr * old ) override final {
    23662355                auto rslt = new ast::UniqueExpr(
    23672356                        old->location,
    … …  
    23752364        }
    23762365
    2377         virtual void visit( UntypedInitExpr * old ) override final {
     2366        virtual void visit( const UntypedInitExpr * old ) override final {
    23782367                std::deque<ast::InitAlternative> initAlts;
    23792368                for (auto ia : old->initAlts) {
    … …  
    23922381        }
    23932382
    2394         virtual void visit( InitExpr * old ) override final {
     2383        virtual void visit( const InitExpr * old ) override final {
    23952384                this->node = visitBaseExpr( old,
    23962385                        new ast::InitExpr(
    … …  
    24022391        }
    24032392
    2404         virtual void visit( DeletedExpr * old ) override final {
     2393        virtual void visit( const DeletedExpr * old ) override final {
    24052394                this->node = visitBaseExpr( old,
    24062395                        new ast::DeletedExpr(
    … …  
    24082397                                GET_ACCEPT_1(expr, Expr),
    24092398                                inCache(old->deleteStmt) ?
    2410                                         this->node :
    2411                                         GET_ACCEPT_1(deleteStmt, Node)
    2412                         )
    2413                 );
    2414         }
    2415 
    2416         virtual void visit( DefaultArgExpr * old ) override final {
     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 {
    24172406                this->node = visitBaseExpr( old,
    24182407                        new ast::DefaultArgExpr(
    … …  
    24232412        }
    24242413
    2425         virtual void visit( GenericExpr * old ) override final {
     2414        virtual void visit( const GenericExpr * old ) override final {
    24262415                std::vector<ast::GenericExpr::Association> associations;
    24272416                for (auto association : old->associations) {
    … …  
    24402429        }
    24412430
    2442         void visitType( Type * old, ast::Type * type ) {
     2431        void visitType( const Type * old, ast::Type * type ) {
    24432432                // Some types do this in their constructor so add a check.
    24442433                if ( !old->attributes.empty() && type->attributes.empty() ) {
    … …  
    24482437        }
    24492438
    2450         virtual void visit( VoidType * old ) override final {
     2439        virtual void visit( const VoidType * old ) override final {
    24512440                visitType( old, new ast::VoidType{ cv( old ) } );
    24522441        }
    24532442
    2454         virtual void visit( BasicType * old ) override final {
     2443        virtual void visit( const BasicType * old ) override final {
    24552444                auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
    24562445                // I believe this should always be a BasicType.
    … …  
    24612450        }
    24622451
    2463         virtual void visit( PointerType * old ) override final {
     2452        virtual void visit( const PointerType * old ) override final {
    24642453                visitType( old, new ast::PointerType{
    24652454                        GET_ACCEPT_1( base, Type ),
    … …  
    24712460        }
    24722461
    2473         virtual void visit( ArrayType * old ) override final {
     2462        virtual void visit( const ArrayType * old ) override final {
    24742463                visitType( old, new ast::ArrayType{
    24752464                        GET_ACCEPT_1( base, Type ),
    … …  
    24812470        }
    24822471
    2483         virtual void visit( ReferenceType * old ) override final {
     2472        virtual void visit( const ReferenceType * old ) override final {
    24842473                visitType( old, new ast::ReferenceType{
    24852474                        GET_ACCEPT_1( base, Type ),
    … …  
    24882477        }
    24892478
    2490         virtual void visit( QualifiedType * old ) override final {
     2479        virtual void visit( const QualifiedType * old ) override final {
    24912480                visitType( old, new ast::QualifiedType{
    24922481                        GET_ACCEPT_1( parent, Type ),
    … …  
    24962485        }
    24972486
    2498         virtual void visit( FunctionType * old ) override final {
     2487        virtual void visit( const FunctionType * old ) override final {
    24992488                auto ty = new ast::FunctionType {
    25002489                        (ast::ArgumentFlag)old->isVarArgs,
    … …  
    25072496        }
    25082497
    2509         void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
     2498        void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
    25102499                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
    25112500                ty->params = GET_ACCEPT_V( parameters, Expr );
    … …  
    25142503        }
    25152504
    2516         virtual void visit( StructInstType * old ) override final {
     2505        virtual void visit( const StructInstType * old ) override final {
    25172506                ast::StructInstType * ty;
    25182507                if ( old->baseStruct ) {
    … …  
    25322521        }
    25332522
    2534         virtual void visit( UnionInstType * old ) override final {
     2523        virtual void visit( const UnionInstType * old ) override final {
    25352524                ast::UnionInstType * ty;
    25362525                if ( old->baseUnion ) {
    … …  
    25502539        }
    25512540
    2552         virtual void visit( EnumInstType * old ) override final {
     2541        virtual void visit( const EnumInstType * old ) override final {
    25532542                ast::EnumInstType * ty;
    25542543                if ( old->baseEnum ) {
    … …  
    25682557        }
    25692558
    2570         virtual void visit( TraitInstType * old ) override final {
     2559        virtual void visit( const TraitInstType * old ) override final {
    25712560                ast::TraitInstType * ty;
    25722561                if ( old->baseTrait ) {
    … …  
    25862575        }
    25872576
    2588         virtual void visit( TypeInstType * old ) override final {
     2577        virtual void visit( const TypeInstType * old ) override final {
    25892578                ast::TypeInstType * ty;
    25902579                if ( old->baseType ) {
    … …  
    26062595        }
    26072596
    2608         virtual void visit( TupleType * old ) override final {
     2597        virtual void visit( const TupleType * old ) override final {
    26092598                visitType( old, new ast::TupleType{
    26102599                        GET_ACCEPT_V( types, Type ),
    … …  
    26142603        }
    26152604
    2616         virtual void visit( TypeofType * old ) override final {
     2605        virtual void visit( const TypeofType * old ) override final {
    26172606                visitType( old, new ast::TypeofType{
    26182607                        GET_ACCEPT_1( expr, Expr ),
    … …  
    26222611        }
    26232612
    2624         virtual void visit( AttrType * ) override final {
     2613        virtual void visit( const AttrType * ) override final {
    26252614                assertf( false, "AttrType deprecated in new AST." );
    26262615        }
    26272616
    2628         virtual void visit( VarArgsType * old ) override final {
     2617        virtual void visit( const VarArgsType * old ) override final {
    26292618                visitType( old, new ast::VarArgsType{ cv( old ) } );
    26302619        }
    26312620
    2632         virtual void visit( ZeroType * old ) override final {
     2621        virtual void visit( const ZeroType * old ) override final {
    26332622                visitType( old, new ast::ZeroType{ cv( old ) } );
    26342623        }
    26352624
    2636         virtual void visit( OneType * old ) override final {
     2625        virtual void visit( const OneType * old ) override final {
    26372626                visitType( old, new ast::OneType{ cv( old ) } );
    26382627        }
    26392628
    2640         virtual void visit( GlobalScopeType * old ) override final {
     2629        virtual void visit( const GlobalScopeType * old ) override final {
    26412630                visitType( old, new ast::GlobalScopeType{} );
    26422631        }
    26432632
    2644         virtual void visit( Designation * old ) override final {
     2633        virtual void visit( const Designation * old ) override final {
    26452634                this->node = new ast::Designation(
    26462635                        old->location,
    … …  
    26492638        }
    26502639
    2651         virtual void visit( SingleInit * old ) override final {
     2640        virtual void visit( const SingleInit * old ) override final {
    26522641                this->node = new ast::SingleInit(
    26532642                        old->location,
    … …  
    26572646        }
    26582647
    2659         virtual void visit( ListInit * old ) override final {
     2648        virtual void visit( const ListInit * old ) override final {
    26602649                this->node = new ast::ListInit(
    26612650                        old->location,
    … …  
    26662655        }
    26672656
    2668         virtual void visit( ConstructorInit * old ) override final {
     2657        virtual void visit( const ConstructorInit * old ) override final {
    26692658                this->node = new ast::ConstructorInit(
    26702659                        old->location,
    … …  
    26752664        }
    26762665
    2677         virtual void visit( Constant * ) override final {
     2666        virtual void visit( const Constant * ) override final {
    26782667                // Handled in visit( ConstantEpxr * ).
    26792668                // In the new tree, Constant fields are inlined into containing ConstantExpression.
    … …  
    26812670        }
    26822671
    2683         virtual void visit( Attribute * old ) override final {
     2672        virtual void visit( const Attribute * old ) override final {
    26842673                this->node = new ast::Attribute(
    26852674                        old->name,
    … …  
    26882677        }
    26892678
    2690         virtual void visit( AttrExpr * ) override final {
     2679        virtual void visit( const AttrExpr * ) override final {
    26912680                assertf( false, "AttrExpr deprecated in new AST." );
    26922681        }
Note: See TracChangeset for help on using the changeset viewer.