Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    rf6cc734e rae265b55  
    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
    … …  
    10501051                                get<Expression>().accept1(node->expr),
    10511052                                inCache(node->deleteStmt) ?
    1052                                         this->node :
    1053                                         get<BaseSyntaxNode>().accept1(node->deleteStmt)
     1053                                        strict_dynamic_cast<Declaration*>(this->node) :
     1054                                        get<Declaration>().accept1(node->deleteStmt)
    10541055                        )
    10551056                );
    … …  
    13661367        ast::Node * node = nullptr;
    13671368        /// cache of nodes that might be referenced by readonly<> for de-duplication
    1368         std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
     1369        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
    13691370
    13701371        // Local Utilities:
    … …  
    14331434                to<std::vector>::from( make_labels( std::move( labels ) ) )
    14341435
    1435         static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
     1436        static ast::CV::Qualifiers cv( const Type * ty ) { return { ty->tq.val }; }
    14361437
    14371438        /// returns true and sets `node` if in cache
    1438         bool inCache( BaseSyntaxNode * old ) {
     1439        bool inCache( const BaseSyntaxNode * old ) {
    14391440                auto it = cache.find( old );
    14401441                if ( it == cache.end() ) return false;
    … …  
    14451446        // Now all the visit functions:
    14461447
    1447         virtual void visit( ObjectDecl * old ) override final {
     1448        virtual void visit( const ObjectDecl * old ) override final {
    14481449                auto&& type = GET_ACCEPT_1(type, Type);
    14491450                auto&& init = GET_ACCEPT_1(init, Init);
    … …  
    14761477        }
    14771478
    1478         virtual void visit( FunctionDecl * old ) override final {
     1479        virtual void visit( const FunctionDecl * old ) override final {
    14791480                if ( inCache( old ) ) return;
    14801481                auto decl = new ast::FunctionDecl{
    … …  
    15091510        }
    15101511
    1511         virtual void visit( StructDecl * old ) override final {
     1512        virtual void visit( const StructDecl * old ) override final {
    15121513                if ( inCache( old ) ) return;
    15131514                auto decl = new ast::StructDecl(
    … …  
    15341535        }
    15351536
    1536         virtual void visit( UnionDecl * old ) override final {
     1537        virtual void visit( const UnionDecl * old ) override final {
    15371538                if ( inCache( old ) ) return;
    15381539                auto decl = new ast::UnionDecl(
    … …  
    15541555        }
    15551556
    1556         virtual void visit( EnumDecl * old ) override final {
     1557        virtual void visit( const EnumDecl * old ) override final {
    15571558                if ( inCache( old ) ) return;
    15581559                auto decl = new ast::EnumDecl(
    … …  
    15741575        }
    15751576
    1576         virtual void visit( TraitDecl * old ) override final {
     1577        virtual void visit( const TraitDecl * old ) override final {
    15771578                if ( inCache( old ) ) return;
    15781579                auto decl = new ast::TraitDecl(
    … …  
    15941595        }
    15951596
    1596         virtual void visit( TypeDecl * old ) override final {
     1597        virtual void visit( const TypeDecl * old ) override final {
    15971598                if ( inCache( old ) ) return;
    15981599                auto decl = new ast::TypeDecl{
    … …  
    16141615        }
    16151616
    1616         virtual void visit( TypedefDecl * old ) override final {
     1617        virtual void visit( const TypedefDecl * old ) override final {
    16171618                auto decl = new ast::TypedefDecl(
    16181619                        old->location,
    … …  
    16311632        }
    16321633
    1633         virtual void visit( AsmDecl * old ) override final {
     1634        virtual void visit( const AsmDecl * old ) override final {
    16341635                auto decl = new ast::AsmDecl{
    16351636                        old->location,
    … …  
    16431644        }
    16441645
    1645         virtual void visit( StaticAssertDecl * old ) override final {
     1646        virtual void visit( const StaticAssertDecl * old ) override final {
    16461647                auto decl = new ast::StaticAssertDecl{
    16471648                        old->location,
    … …  
    16561657        }
    16571658
    1658         virtual void visit( CompoundStmt * old ) override final {
     1659        virtual void visit( const CompoundStmt * old ) override final {
    16591660                if ( inCache( old ) ) return;
    16601661                auto stmt = new ast::CompoundStmt(
    … …  
    16681669        }
    16691670
    1670         virtual void visit( ExprStmt * old ) override final {
     1671        virtual void visit( const ExprStmt * old ) override final {
    16711672                if ( inCache( old ) ) return;
    16721673                this->node = new ast::ExprStmt(
    … …  
    16781679        }
    16791680
    1680         virtual void visit( AsmStmt * old ) override final {
     1681        virtual void visit( const AsmStmt * old ) override final {
    16811682                if ( inCache( old ) ) return;
    16821683                this->node = new ast::AsmStmt(
    … …  
    16931694        }
    16941695
    1695         virtual void visit( DirectiveStmt * old ) override final {
     1696        virtual void visit( const DirectiveStmt * old ) override final {
    16961697                if ( inCache( old ) ) return;
    16971698                this->node = new ast::DirectiveStmt(
    … …  
    17031704        }
    17041705
    1705         virtual void visit( IfStmt * old ) override final {
     1706        virtual void visit( const IfStmt * old ) override final {
    17061707                if ( inCache( old ) ) return;
    17071708                this->node = new ast::IfStmt(
    … …  
    17161717        }
    17171718
    1718         virtual void visit( SwitchStmt * old ) override final {
     1719        virtual void visit( const SwitchStmt * old ) override final {
    17191720                if ( inCache( old ) ) return;
    17201721                this->node = new ast::SwitchStmt(
    … …  
    17271728        }
    17281729
    1729         virtual void visit( CaseStmt * old ) override final {
     1730        virtual void visit( const CaseStmt * old ) override final {
    17301731                if ( inCache( old ) ) return;
    17311732                this->node = new ast::CaseStmt(
    … …  
    17381739        }
    17391740
    1740         virtual void visit( WhileStmt * old ) override final {
     1741        virtual void visit( const WhileStmt * old ) override final {
    17411742                if ( inCache( old ) ) return;
    17421743                this->node = new ast::WhileStmt(
    … …  
    17511752        }
    17521753
    1753         virtual void visit( ForStmt * old ) override final {
     1754        virtual void visit( const ForStmt * old ) override final {
    17541755                if ( inCache( old ) ) return;
    17551756                this->node = new ast::ForStmt(
    … …  
    17641765        }
    17651766
    1766         virtual void visit( BranchStmt * old ) override final {
     1767        virtual void visit( const BranchStmt * old ) override final {
    17671768                if ( inCache( old ) ) return;
    17681769                if (old->computedTarget) {
    … …  
    18011802        }
    18021803
    1803         virtual void visit( ReturnStmt * old ) override final {
     1804        virtual void visit( const ReturnStmt * old ) override final {
    18041805                if ( inCache( old ) ) return;
    18051806                this->node = new ast::ReturnStmt(
    … …  
    18111812        }
    18121813
    1813         virtual void visit( ThrowStmt * old ) override final {
     1814        virtual void visit( const ThrowStmt * old ) override final {
    18141815                if ( inCache( old ) ) return;
    18151816                ast::ExceptionKind kind;
    … …  
    18351836        }
    18361837
    1837         virtual void visit( TryStmt * old ) override final {
     1838        virtual void visit( const TryStmt * old ) override final {
    18381839                if ( inCache( old ) ) return;
    18391840                this->node = new ast::TryStmt(
    … …  
    18471848        }
    18481849
    1849         virtual void visit( CatchStmt * old ) override final {
     1850        virtual void visit( const CatchStmt * old ) override final {
    18501851                if ( inCache( old ) ) return;
    18511852                ast::ExceptionKind kind;
    … …  
    18721873        }
    18731874
    1874         virtual void visit( FinallyStmt * old ) override final {
     1875        virtual void visit( const FinallyStmt * old ) override final {
    18751876                if ( inCache( old ) ) return;
    18761877                this->node = new ast::FinallyStmt(
    … …  
    18821883        }
    18831884
    1884         virtual void visit( WaitForStmt * old ) override final {
     1885        virtual void visit( const WaitForStmt * old ) override final {
    18851886                if ( inCache( old ) ) return;
    18861887                ast::WaitForStmt * stmt = new ast::WaitForStmt(
    … …  
    19141915        }
    19151916
    1916         virtual void visit( WithStmt * old ) override final {
     1917        virtual void visit( const WithStmt * old ) override final {
    19171918                if ( inCache( old ) ) return;
    19181919                this->node = new ast::WithStmt(
    19191920                        old->location,
    19201921                        GET_ACCEPT_V(exprs, Expr),
    1921                         GET_ACCEPT_1(stmt, Stmt),
    1922                         GET_LABELS_V(old->labels)
     1922                        GET_ACCEPT_1(stmt, Stmt)
    19231923                );
    19241924                cache.emplace( old, this->node );
    19251925        }
    19261926
    1927         virtual void visit( NullStmt * old ) override final {
     1927        virtual void visit( const NullStmt * old ) override final {
    19281928                if ( inCache( old ) ) return;
    19291929                this->node = new ast::NullStmt(
    … …  
    19341934        }
    19351935
    1936         virtual void visit( DeclStmt * old ) override final {
     1936        virtual void visit( const DeclStmt * old ) override final {
    19371937                if ( inCache( old ) ) return;
    19381938                this->node = new ast::DeclStmt(
    … …  
    19441944        }
    19451945
    1946         virtual void visit( ImplicitCtorDtorStmt * old ) override final {
     1946        virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
    19471947                if ( inCache( old ) ) return;
    19481948                auto stmt = new ast::ImplicitCtorDtorStmt(
    … …  
    20012001        }
    20022002
    2003         ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
     2003        ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
    20042004
    20052005                nw->env    = convertTypeSubstitution(old->env);
    … …  
    20112011        }
    20122012
    2013         ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
     2013        ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
    20142014
    20152015                nw->result = GET_ACCEPT_1(result, Type);
    … …  
    20172017        }
    20182018
    2019         virtual void visit( ApplicationExpr * old ) override final {
     2019        virtual void visit( const ApplicationExpr * old ) override final {
    20202020                this->node = visitBaseExpr( old,
    20212021                        new ast::ApplicationExpr(
    … …  
    20272027        }
    20282028
    2029         virtual void visit( UntypedExpr * old ) override final {
     2029        virtual void visit( const UntypedExpr * old ) override final {
    20302030                this->node = visitBaseExpr( old,
    20312031                        new ast::UntypedExpr(
    … …  
    20372037        }
    20382038
    2039         virtual void visit( NameExpr * old ) override final {
     2039        virtual void visit( const NameExpr * old ) override final {
    20402040                this->node = visitBaseExpr( old,
    20412041                        new ast::NameExpr(
    … …  
    20462046        }
    20472047
    2048         virtual void visit( CastExpr * old ) override final {
     2048        virtual void visit( const CastExpr * old ) override final {
    20492049                this->node = visitBaseExpr( old,
    20502050                        new ast::CastExpr(
    … …  
    20562056        }
    20572057
    2058         virtual void visit( KeywordCastExpr * old) override final {
     2058        virtual void visit( const KeywordCastExpr * old) override final {
    20592059                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    20602060                switch (old->target) {
    … …  
    20812081        }
    20822082
    2083         virtual void visit( VirtualCastExpr * old ) override final {
     2083        virtual void visit( const VirtualCastExpr * old ) override final {
    20842084                this->node = visitBaseExpr_SkipResultType( old,
    20852085                        new ast::VirtualCastExpr(
    … …  
    20912091        }
    20922092
    2093         virtual void visit( AddressExpr * old ) override final {
     2093        virtual void visit( const AddressExpr * old ) override final {
    20942094                this->node = visitBaseExpr( old,
    20952095                        new ast::AddressExpr(
    … …  
    21002100        }
    21012101
    2102         virtual void visit( LabelAddressExpr * old ) override final {
     2102        virtual void visit( const LabelAddressExpr * old ) override final {
    21032103                this->node = visitBaseExpr( old,
    21042104                        new ast::LabelAddressExpr(
    … …  
    21092109        }
    21102110
    2111         virtual void visit( UntypedMemberExpr * old ) override final {
     2111        virtual void visit( const UntypedMemberExpr * old ) override final {
    21122112                this->node = visitBaseExpr( old,
    21132113                        new ast::UntypedMemberExpr(
    … …  
    21192119        }
    21202120
    2121         virtual void visit( MemberExpr * old ) override final {
     2121        virtual void visit( const MemberExpr * old ) override final {
    21222122                this->node = visitBaseExpr( old,
    21232123                        new ast::MemberExpr(
    21242124                                old->location,
    21252125                                GET_ACCEPT_1(member, DeclWithType),
    2126                                 GET_ACCEPT_1(aggregate, Expr)
    2127                         )
    2128                 );
    2129         }
    2130 
    2131         virtual void visit( VariableExpr * old ) override final {
     2126                                GET_ACCEPT_1(aggregate, Expr),
     2127                                ast::MemberExpr::NoOpConstructionChosen
     2128                        )
     2129                );
     2130        }
     2131
     2132        virtual void visit( const VariableExpr * old ) override final {
    21322133                auto expr = new ast::VariableExpr(
    21332134                        old->location
    … …  
    21402141        }
    21412142
    2142         virtual void visit( ConstantExpr * old ) override final {
     2143        virtual void visit( const ConstantExpr * old ) override final {
    21432144                ast::ConstantExpr *rslt = new ast::ConstantExpr(
    21442145                        old->location,
    21452146                        GET_ACCEPT_1(result, Type),
    2146                         old->constant.get_value(),
     2147                        old->constant.rep,
    21472148                        old->constant.ival
    21482149                );
    2149                 rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
     2150                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
    21502151                this->node = visitBaseExpr( old, rslt );
    21512152        }
    21522153
    2153         virtual void visit( SizeofExpr * old ) override final {
     2154        virtual void visit( const SizeofExpr * old ) override final {
    21542155                assert (old->expr || old->type);
    21552156                assert (! (old->expr && old->type));
    … …  
    21722173        }
    21732174
    2174         virtual void visit( AlignofExpr * old ) override final {
     2175        virtual void visit( const AlignofExpr * old ) override final {
    21752176                assert (old->expr || old->type);
    21762177                assert (! (old->expr && old->type));
    … …  
    21932194        }
    21942195
    2195         virtual void visit( UntypedOffsetofExpr * old ) override final {
     2196        virtual void visit( const UntypedOffsetofExpr * old ) override final {
    21962197                this->node = visitBaseExpr( old,
    21972198                        new ast::UntypedOffsetofExpr(
    … …  
    22032204        }
    22042205
    2205         virtual void visit( OffsetofExpr * old ) override final {
     2206        virtual void visit( const OffsetofExpr * old ) override final {
    22062207                this->node = visitBaseExpr( old,
    22072208                        new ast::OffsetofExpr(
    … …  
    22132214        }
    22142215
    2215         virtual void visit( OffsetPackExpr * old ) override final {
     2216        virtual void visit( const OffsetPackExpr * old ) override final {
    22162217                this->node = visitBaseExpr( old,
    22172218                        new ast::OffsetPackExpr(
    … …  
    22222223        }
    22232224
    2224         virtual void visit( LogicalExpr * old ) override final {
     2225        virtual void visit( const LogicalExpr * old ) override final {
    22252226                this->node = visitBaseExpr( old,
    22262227                        new ast::LogicalExpr(
    … …  
    22352236        }
    22362237
    2237         virtual void visit( ConditionalExpr * old ) override final {
     2238        virtual void visit( const ConditionalExpr * old ) override final {
    22382239                this->node = visitBaseExpr( old,
    22392240                        new ast::ConditionalExpr(
    … …  
    22462247        }
    22472248
    2248         virtual void visit( CommaExpr * old ) override final {
     2249        virtual void visit( const CommaExpr * old ) override final {
    22492250                this->node = visitBaseExpr( old,
    22502251                        new ast::CommaExpr(
    … …  
    22562257        }
    22572258
    2258         virtual void visit( TypeExpr * old ) override final {
     2259        virtual void visit( const TypeExpr * old ) override final {
    22592260                this->node = visitBaseExpr( old,
    22602261                        new ast::TypeExpr(
    … …  
    22652266        }
    22662267
    2267         virtual void visit( AsmExpr * old ) override final {
     2268        virtual void visit( const AsmExpr * old ) override final {
    22682269                this->node = visitBaseExpr( old,
    22692270                        new ast::AsmExpr(
    … …  
    22762277        }
    22772278
    2278         virtual void visit( ImplicitCopyCtorExpr * old ) override final {
     2279        virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
    22792280                auto rslt = new ast::ImplicitCopyCtorExpr(
    22802281                        old->location,
    … …  
    22852286        }
    22862287
    2287         virtual void visit( ConstructorExpr * old ) override final {
     2288        virtual void visit( const ConstructorExpr * old ) override final {
    22882289                this->node = visitBaseExpr( old,
    22892290                        new ast::ConstructorExpr(
    … …  
    22942295        }
    22952296
    2296         virtual void visit( CompoundLiteralExpr * old ) override final {
     2297        virtual void visit( const CompoundLiteralExpr * old ) override final {
    22972298                this->node = visitBaseExpr_SkipResultType( old,
    22982299                        new ast::CompoundLiteralExpr(
    … …  
    23042305        }
    23052306
    2306         virtual void visit( RangeExpr * old ) override final {
     2307        virtual void visit( const RangeExpr * old ) override final {
    23072308                this->node = visitBaseExpr( old,
    23082309                        new ast::RangeExpr(
    … …  
    23142315        }
    23152316
    2316         virtual void visit( UntypedTupleExpr * old ) override final {
     2317        virtual void visit( const UntypedTupleExpr * old ) override final {
    23172318                this->node = visitBaseExpr( old,
    23182319                        new ast::UntypedTupleExpr(
    … …  
    23232324        }
    23242325
    2325         virtual void visit( TupleExpr * old ) override final {
     2326        virtual void visit( const TupleExpr * old ) override final {
    23262327                this->node = visitBaseExpr( old,
    23272328                        new ast::TupleExpr(
    … …  
    23322333        }
    23332334
    2334         virtual void visit( TupleIndexExpr * old ) override final {
     2335        virtual void visit( const TupleIndexExpr * old ) override final {
    23352336                this->node = visitBaseExpr( old,
    23362337                        new ast::TupleIndexExpr(
    … …  
    23422343        }
    23432344
    2344         virtual void visit( TupleAssignExpr * old ) override final {
     2345        virtual void visit( const TupleAssignExpr * old ) override final {
    23452346                this->node = visitBaseExpr_SkipResultType( old,
    23462347                        new ast::TupleAssignExpr(
    … …  
    23522353        }
    23532354
    2354         virtual void visit( StmtExpr * old ) override final {
     2355        virtual void visit( const StmtExpr * old ) override final {
    23552356                auto rslt = new ast::StmtExpr(
    23562357                        old->location,
    … …  
    23632364        }
    23642365
    2365         virtual void visit( UniqueExpr * old ) override final {
     2366        virtual void visit( const UniqueExpr * old ) override final {
    23662367                auto rslt = new ast::UniqueExpr(
    23672368                        old->location,
    … …  
    23752376        }
    23762377
    2377         virtual void visit( UntypedInitExpr * old ) override final {
     2378        virtual void visit( const UntypedInitExpr * old ) override final {
    23782379                std::deque<ast::InitAlternative> initAlts;
    23792380                for (auto ia : old->initAlts) {
    … …  
    23922393        }
    23932394
    2394         virtual void visit( InitExpr * old ) override final {
     2395        virtual void visit( const InitExpr * old ) override final {
    23952396                this->node = visitBaseExpr( old,
    23962397                        new ast::InitExpr(
    … …  
    24022403        }
    24032404
    2404         virtual void visit( DeletedExpr * old ) override final {
     2405        virtual void visit( const DeletedExpr * old ) override final {
    24052406                this->node = visitBaseExpr( old,
    24062407                        new ast::DeletedExpr(
    … …  
    24082409                                GET_ACCEPT_1(expr, Expr),
    24092410                                inCache(old->deleteStmt) ?
    2410                                         this->node :
    2411                                         GET_ACCEPT_1(deleteStmt, Node)
    2412                         )
    2413                 );
    2414         }
    2415 
    2416         virtual void visit( DefaultArgExpr * old ) override final {
     2411                                        strict_dynamic_cast<ast::Decl*>(this->node) :
     2412                                        GET_ACCEPT_1(deleteStmt, Decl)
     2413                        )
     2414                );
     2415        }
     2416
     2417        virtual void visit( const DefaultArgExpr * old ) override final {
    24172418                this->node = visitBaseExpr( old,
    24182419                        new ast::DefaultArgExpr(
    … …  
    24232424        }
    24242425
    2425         virtual void visit( GenericExpr * old ) override final {
     2426        virtual void visit( const GenericExpr * old ) override final {
    24262427                std::vector<ast::GenericExpr::Association> associations;
    24272428                for (auto association : old->associations) {
    … …  
    24402441        }
    24412442
    2442         void visitType( Type * old, ast::Type * type ) {
     2443        void visitType( const Type * old, ast::Type * type ) {
    24432444                // Some types do this in their constructor so add a check.
    24442445                if ( !old->attributes.empty() && type->attributes.empty() ) {
    … …  
    24482449        }
    24492450
    2450         virtual void visit( VoidType * old ) override final {
     2451        virtual void visit( const VoidType * old ) override final {
    24512452                visitType( old, new ast::VoidType{ cv( old ) } );
    24522453        }
    24532454
    2454         virtual void visit( BasicType * old ) override final {
     2455        virtual void visit( const BasicType * old ) override final {
    24552456                auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
    24562457                // I believe this should always be a BasicType.
    … …  
    24612462        }
    24622463
    2463         virtual void visit( PointerType * old ) override final {
     2464        virtual void visit( const PointerType * old ) override final {
    24642465                visitType( old, new ast::PointerType{
    24652466                        GET_ACCEPT_1( base, Type ),
    … …  
    24712472        }
    24722473
    2473         virtual void visit( ArrayType * old ) override final {
     2474        virtual void visit( const ArrayType * old ) override final {
    24742475                visitType( old, new ast::ArrayType{
    24752476                        GET_ACCEPT_1( base, Type ),
    … …  
    24812482        }
    24822483
    2483         virtual void visit( ReferenceType * old ) override final {
     2484        virtual void visit( const ReferenceType * old ) override final {
    24842485                visitType( old, new ast::ReferenceType{
    24852486                        GET_ACCEPT_1( base, Type ),
    … …  
    24882489        }
    24892490
    2490         virtual void visit( QualifiedType * old ) override final {
     2491        virtual void visit( const QualifiedType * old ) override final {
    24912492                visitType( old, new ast::QualifiedType{
    24922493                        GET_ACCEPT_1( parent, Type ),
    … …  
    24962497        }
    24972498
    2498         virtual void visit( FunctionType * old ) override final {
     2499        virtual void visit( const FunctionType * old ) override final {
    24992500                auto ty = new ast::FunctionType {
    25002501                        (ast::ArgumentFlag)old->isVarArgs,
    … …  
    25072508        }
    25082509
    2509         void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
     2510        void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
    25102511                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
    25112512                ty->params = GET_ACCEPT_V( parameters, Expr );
    … …  
    25142515        }
    25152516
    2516         virtual void visit( StructInstType * old ) override final {
     2517        virtual void visit( const StructInstType * old ) override final {
    25172518                ast::StructInstType * ty;
    25182519                if ( old->baseStruct ) {
    … …  
    25322533        }
    25332534
    2534         virtual void visit( UnionInstType * old ) override final {
     2535        virtual void visit( const UnionInstType * old ) override final {
    25352536                ast::UnionInstType * ty;
    25362537                if ( old->baseUnion ) {
    … …  
    25502551        }
    25512552
    2552         virtual void visit( EnumInstType * old ) override final {
     2553        virtual void visit( const EnumInstType * old ) override final {
    25532554                ast::EnumInstType * ty;
    25542555                if ( old->baseEnum ) {
    … …  
    25682569        }
    25692570
    2570         virtual void visit( TraitInstType * old ) override final {
     2571        virtual void visit( const TraitInstType * old ) override final {
    25712572                ast::TraitInstType * ty;
    25722573                if ( old->baseTrait ) {
    … …  
    25862587        }
    25872588
    2588         virtual void visit( TypeInstType * old ) override final {
     2589        virtual void visit( const TypeInstType * old ) override final {
    25892590                ast::TypeInstType * ty;
    25902591                if ( old->baseType ) {
    … …  
    26062607        }
    26072608
    2608         virtual void visit( TupleType * old ) override final {
     2609        virtual void visit( const TupleType * old ) override final {
    26092610                visitType( old, new ast::TupleType{
    26102611                        GET_ACCEPT_V( types, Type ),
    … …  
    26142615        }
    26152616
    2616         virtual void visit( TypeofType * old ) override final {
     2617        virtual void visit( const TypeofType * old ) override final {
    26172618                visitType( old, new ast::TypeofType{
    26182619                        GET_ACCEPT_1( expr, Expr ),
    … …  
    26222623        }
    26232624
    2624         virtual void visit( AttrType * ) override final {
     2625        virtual void visit( const AttrType * ) override final {
    26252626                assertf( false, "AttrType deprecated in new AST." );
    26262627        }
    26272628
    2628         virtual void visit( VarArgsType * old ) override final {
     2629        virtual void visit( const VarArgsType * old ) override final {
    26292630                visitType( old, new ast::VarArgsType{ cv( old ) } );
    26302631        }
    26312632
    2632         virtual void visit( ZeroType * old ) override final {
     2633        virtual void visit( const ZeroType * old ) override final {
    26332634                visitType( old, new ast::ZeroType{ cv( old ) } );
    26342635        }
    26352636
    2636         virtual void visit( OneType * old ) override final {
     2637        virtual void visit( const OneType * old ) override final {
    26372638                visitType( old, new ast::OneType{ cv( old ) } );
    26382639        }
    26392640
    2640         virtual void visit( GlobalScopeType * old ) override final {
     2641        virtual void visit( const GlobalScopeType * old ) override final {
    26412642                visitType( old, new ast::GlobalScopeType{} );
    26422643        }
    26432644
    2644         virtual void visit( Designation * old ) override final {
     2645        virtual void visit( const Designation * old ) override final {
    26452646                this->node = new ast::Designation(
    26462647                        old->location,
    … …  
    26492650        }
    26502651
    2651         virtual void visit( SingleInit * old ) override final {
     2652        virtual void visit( const SingleInit * old ) override final {
    26522653                this->node = new ast::SingleInit(
    26532654                        old->location,
    … …  
    26572658        }
    26582659
    2659         virtual void visit( ListInit * old ) override final {
     2660        virtual void visit( const ListInit * old ) override final {
    26602661                this->node = new ast::ListInit(
    26612662                        old->location,
    … …  
    26662667        }
    26672668
    2668         virtual void visit( ConstructorInit * old ) override final {
     2669        virtual void visit( const ConstructorInit * old ) override final {
    26692670                this->node = new ast::ConstructorInit(
    26702671                        old->location,
    … …  
    26752676        }
    26762677
    2677         virtual void visit( Constant * ) override final {
     2678        virtual void visit( const Constant * ) override final {
    26782679                // Handled in visit( ConstantEpxr * ).
    26792680                // In the new tree, Constant fields are inlined into containing ConstantExpression.
    … …  
    26812682        }
    26822683
    2683         virtual void visit( Attribute * old ) override final {
     2684        virtual void visit( const Attribute * old ) override final {
    26842685                this->node = new ast::Attribute(
    26852686                        old->name,
    … …  
    26882689        }
    26892690
    2690         virtual void visit( AttrExpr * ) override final {
     2691        virtual void visit( const AttrExpr * ) override final {
    26912692                assertf( false, "AttrExpr deprecated in new AST." );
    26922693        }
Note: See TracChangeset for help on using the changeset viewer.