Changeset 7870799 for src/AST


Ignore:
Timestamp:
Jul 12, 2019, 10:49:02 AM (6 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
ef5b828
Parents:
ee6dbae
Message:

Cast cost and conversion cost now take constant parameters.
This required supporting visiting const node.
The PassVisitor can now visit const nodes but not when using the Indexer

Location:
src/AST
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    ree6dbae r7870799  
    13551355        ast::Node * node = nullptr;
    13561356        /// cache of nodes that might be referenced by readonly<> for de-duplication
    1357         std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
     1357        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
    13581358
    13591359        // Local Utilities:
    … …  
    14221422                to<std::vector>::from( make_labels( std::move( labels ) ) )
    14231423
    1424         static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
     1424        static ast::CV::Qualifiers cv( const Type * ty ) { return { ty->tq.val }; }
    14251425
    14261426        /// returns true and sets `node` if in cache
    1427         bool inCache( BaseSyntaxNode * old ) {
     1427        bool inCache( const BaseSyntaxNode * old ) {
    14281428                auto it = cache.find( old );
    14291429                if ( it == cache.end() ) return false;
    … …  
    14341434        // Now all the visit functions:
    14351435
    1436         virtual void visit( ObjectDecl * old ) override final {
     1436        virtual void visit( const ObjectDecl * old ) override final {
    14371437                auto&& type = GET_ACCEPT_1(type, Type);
    14381438                auto&& init = GET_ACCEPT_1(init, Init);
    … …  
    14651465        }
    14661466
    1467         virtual void visit( FunctionDecl * old ) override final {
     1467        virtual void visit( const FunctionDecl * old ) override final {
    14681468                if ( inCache( old ) ) return;
    14691469                auto decl = new ast::FunctionDecl{
    … …  
    14981498        }
    14991499
    1500         virtual void visit( StructDecl * old ) override final {
     1500        virtual void visit( const StructDecl * old ) override final {
    15011501                if ( inCache( old ) ) return;
    15021502                auto decl = new ast::StructDecl(
    … …  
    15231523        }
    15241524
    1525         virtual void visit( UnionDecl * old ) override final {
     1525        virtual void visit( const UnionDecl * old ) override final {
    15261526                if ( inCache( old ) ) return;
    15271527                auto decl = new ast::UnionDecl(
    … …  
    15431543        }
    15441544
    1545         virtual void visit( EnumDecl * old ) override final {
     1545        virtual void visit( const EnumDecl * old ) override final {
    15461546                if ( inCache( old ) ) return;
    15471547                auto decl = new ast::EnumDecl(
    … …  
    15631563        }
    15641564
    1565         virtual void visit( TraitDecl * old ) override final {
     1565        virtual void visit( const TraitDecl * old ) override final {
    15661566                if ( inCache( old ) ) return;
    15671567                auto decl = new ast::TraitDecl(
    … …  
    15831583        }
    15841584
    1585         virtual void visit( TypeDecl * old ) override final {
     1585        virtual void visit( const TypeDecl * old ) override final {
    15861586                if ( inCache( old ) ) return;
    15871587                auto decl = new ast::TypeDecl{
    … …  
    16031603        }
    16041604
    1605         virtual void visit( TypedefDecl * old ) override final {
     1605        virtual void visit( const TypedefDecl * old ) override final {
    16061606                auto decl = new ast::TypedefDecl(
    16071607                        old->location,
    … …  
    16201620        }
    16211621
    1622         virtual void visit( AsmDecl * old ) override final {
     1622        virtual void visit( const AsmDecl * old ) override final {
    16231623                auto decl = new ast::AsmDecl{
    16241624                        old->location,
    … …  
    16321632        }
    16331633
    1634         virtual void visit( StaticAssertDecl * old ) override final {
     1634        virtual void visit( const StaticAssertDecl * old ) override final {
    16351635                auto decl = new ast::StaticAssertDecl{
    16361636                        old->location,
    … …  
    16451645        }
    16461646
    1647         virtual void visit( CompoundStmt * old ) override final {
     1647        virtual void visit( const CompoundStmt * old ) override final {
    16481648                if ( inCache( old ) ) return;
    16491649                auto stmt = new ast::CompoundStmt(
    … …  
    16571657        }
    16581658
    1659         virtual void visit( ExprStmt * old ) override final {
     1659        virtual void visit( const ExprStmt * old ) override final {
    16601660                if ( inCache( old ) ) return;
    16611661                this->node = new ast::ExprStmt(
    … …  
    16671667        }
    16681668
    1669         virtual void visit( AsmStmt * old ) override final {
     1669        virtual void visit( const AsmStmt * old ) override final {
    16701670                if ( inCache( old ) ) return;
    16711671                this->node = new ast::AsmStmt(
    … …  
    16821682        }
    16831683
    1684         virtual void visit( DirectiveStmt * old ) override final {
     1684        virtual void visit( const DirectiveStmt * old ) override final {
    16851685                if ( inCache( old ) ) return;
    16861686                this->node = new ast::DirectiveStmt(
    … …  
    16921692        }
    16931693
    1694         virtual void visit( IfStmt * old ) override final {
     1694        virtual void visit( const IfStmt * old ) override final {
    16951695                if ( inCache( old ) ) return;
    16961696                this->node = new ast::IfStmt(
    … …  
    17051705        }
    17061706
    1707         virtual void visit( SwitchStmt * old ) override final {
     1707        virtual void visit( const SwitchStmt * old ) override final {
    17081708                if ( inCache( old ) ) return;
    17091709                this->node = new ast::SwitchStmt(
    … …  
    17161716        }
    17171717
    1718         virtual void visit( CaseStmt * old ) override final {
     1718        virtual void visit( const CaseStmt * old ) override final {
    17191719                if ( inCache( old ) ) return;
    17201720                this->node = new ast::CaseStmt(
    … …  
    17271727        }
    17281728
    1729         virtual void visit( WhileStmt * old ) override final {
     1729        virtual void visit( const WhileStmt * old ) override final {
    17301730                if ( inCache( old ) ) return;
    17311731                this->node = new ast::WhileStmt(
    … …  
    17401740        }
    17411741
    1742         virtual void visit( ForStmt * old ) override final {
     1742        virtual void visit( const ForStmt * old ) override final {
    17431743                if ( inCache( old ) ) return;
    17441744                this->node = new ast::ForStmt(
    … …  
    17531753        }
    17541754
    1755         virtual void visit( BranchStmt * old ) override final {
     1755        virtual void visit( const BranchStmt * old ) override final {
    17561756                if ( inCache( old ) ) return;
    17571757                if (old->computedTarget) {
    … …  
    17901790        }
    17911791
    1792         virtual void visit( ReturnStmt * old ) override final {
     1792        virtual void visit( const ReturnStmt * old ) override final {
    17931793                if ( inCache( old ) ) return;
    17941794                this->node = new ast::ReturnStmt(
    … …  
    18001800        }
    18011801
    1802         virtual void visit( ThrowStmt * old ) override final {
     1802        virtual void visit( const ThrowStmt * old ) override final {
    18031803                if ( inCache( old ) ) return;
    18041804                ast::ExceptionKind kind;
    … …  
    18241824        }
    18251825
    1826         virtual void visit( TryStmt * old ) override final {
     1826        virtual void visit( const TryStmt * old ) override final {
    18271827                if ( inCache( old ) ) return;
    18281828                this->node = new ast::TryStmt(
    … …  
    18361836        }
    18371837
    1838         virtual void visit( CatchStmt * old ) override final {
     1838        virtual void visit( const CatchStmt * old ) override final {
    18391839                if ( inCache( old ) ) return;
    18401840                ast::ExceptionKind kind;
    … …  
    18611861        }
    18621862
    1863         virtual void visit( FinallyStmt * old ) override final {
     1863        virtual void visit( const FinallyStmt * old ) override final {
    18641864                if ( inCache( old ) ) return;
    18651865                this->node = new ast::FinallyStmt(
    … …  
    18711871        }
    18721872
    1873         virtual void visit( WaitForStmt * old ) override final {
     1873        virtual void visit( const WaitForStmt * old ) override final {
    18741874                if ( inCache( old ) ) return;
    18751875                ast::WaitForStmt * stmt = new ast::WaitForStmt(
    … …  
    19031903        }
    19041904
    1905         virtual void visit( WithStmt * old ) override final {
     1905        virtual void visit( const WithStmt * old ) override final {
    19061906                if ( inCache( old ) ) return;
    19071907                this->node = new ast::WithStmt(
    … …  
    19141914        }
    19151915
    1916         virtual void visit( NullStmt * old ) override final {
     1916        virtual void visit( const NullStmt * old ) override final {
    19171917                if ( inCache( old ) ) return;
    19181918                this->node = new ast::NullStmt(
    … …  
    19231923        }
    19241924
    1925         virtual void visit( DeclStmt * old ) override final {
     1925        virtual void visit( const DeclStmt * old ) override final {
    19261926                if ( inCache( old ) ) return;
    19271927                this->node = new ast::DeclStmt(
    … …  
    19331933        }
    19341934
    1935         virtual void visit( ImplicitCtorDtorStmt * old ) override final {
     1935        virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
    19361936                if ( inCache( old ) ) return;
    19371937                auto stmt = new ast::ImplicitCtorDtorStmt(
    … …  
    19901990        }
    19911991
    1992         ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
     1992        ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
    19931993
    19941994                nw->env    = convertTypeSubstitution(old->env);
    … …  
    20002000        }
    20012001
    2002         ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
     2002        ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
    20032003
    20042004                nw->result = GET_ACCEPT_1(result, Type);
    … …  
    20062006        }
    20072007
    2008         virtual void visit( ApplicationExpr * old ) override final {
     2008        virtual void visit( const ApplicationExpr * old ) override final {
    20092009                this->node = visitBaseExpr( old,
    20102010                        new ast::ApplicationExpr(
    … …  
    20162016        }
    20172017
    2018         virtual void visit( UntypedExpr * old ) override final {
     2018        virtual void visit( const UntypedExpr * old ) override final {
    20192019                this->node = visitBaseExpr( old,
    20202020                        new ast::UntypedExpr(
    … …  
    20262026        }
    20272027
    2028         virtual void visit( NameExpr * old ) override final {
     2028        virtual void visit( const NameExpr * old ) override final {
    20292029                this->node = visitBaseExpr( old,
    20302030                        new ast::NameExpr(
    … …  
    20352035        }
    20362036
    2037         virtual void visit( CastExpr * old ) override final {
     2037        virtual void visit( const CastExpr * old ) override final {
    20382038                this->node = visitBaseExpr( old,
    20392039                        new ast::CastExpr(
    … …  
    20452045        }
    20462046
    2047         virtual void visit( KeywordCastExpr * old) override final {
     2047        virtual void visit( const KeywordCastExpr * old) override final {
    20482048                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    20492049                switch (old->target) {
    … …  
    20702070        }
    20712071
    2072         virtual void visit( VirtualCastExpr * old ) override final {
     2072        virtual void visit( const VirtualCastExpr * old ) override final {
    20732073                this->node = visitBaseExpr_SkipResultType( old,
    20742074                        new ast::VirtualCastExpr(
    … …  
    20802080        }
    20812081
    2082         virtual void visit( AddressExpr * old ) override final {
     2082        virtual void visit( const AddressExpr * old ) override final {
    20832083                this->node = visitBaseExpr( old,
    20842084                        new ast::AddressExpr(
    … …  
    20892089        }
    20902090
    2091         virtual void visit( LabelAddressExpr * old ) override final {
     2091        virtual void visit( const LabelAddressExpr * old ) override final {
    20922092                this->node = visitBaseExpr( old,
    20932093                        new ast::LabelAddressExpr(
    … …  
    20982098        }
    20992099
    2100         virtual void visit( UntypedMemberExpr * old ) override final {
     2100        virtual void visit( const UntypedMemberExpr * old ) override final {
    21012101                this->node = visitBaseExpr( old,
    21022102                        new ast::UntypedMemberExpr(
    … …  
    21082108        }
    21092109
    2110         virtual void visit( MemberExpr * old ) override final {
     2110        virtual void visit( const MemberExpr * old ) override final {
    21112111                this->node = visitBaseExpr( old,
    21122112                        new ast::MemberExpr(
    … …  
    21182118        }
    21192119
    2120         virtual void visit( VariableExpr * old ) override final {
     2120        virtual void visit( const VariableExpr * old ) override final {
    21212121                auto expr = new ast::VariableExpr(
    21222122                        old->location
    … …  
    21292129        }
    21302130
    2131         virtual void visit( ConstantExpr * old ) override final {
     2131        virtual void visit( const ConstantExpr * old ) override final {
    21322132                ast::ConstantExpr *rslt = new ast::ConstantExpr(
    21332133                        old->location,
    21342134                        GET_ACCEPT_1(result, Type),
    2135                         old->constant.get_value(),
     2135                        old->constant.rep,
    21362136                        old->constant.ival
    21372137                );
    2138                 rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
     2138                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
    21392139                this->node = visitBaseExpr( old, rslt );
    21402140        }
    21412141
    2142         virtual void visit( SizeofExpr * old ) override final {
     2142        virtual void visit( const SizeofExpr * old ) override final {
    21432143                assert (old->expr || old->type);
    21442144                assert (! (old->expr && old->type));
    … …  
    21612161        }
    21622162
    2163         virtual void visit( AlignofExpr * old ) override final {
     2163        virtual void visit( const AlignofExpr * old ) override final {
    21642164                assert (old->expr || old->type);
    21652165                assert (! (old->expr && old->type));
    … …  
    21822182        }
    21832183
    2184         virtual void visit( UntypedOffsetofExpr * old ) override final {
     2184        virtual void visit( const UntypedOffsetofExpr * old ) override final {
    21852185                this->node = visitBaseExpr( old,
    21862186                        new ast::UntypedOffsetofExpr(
    … …  
    21922192        }
    21932193
    2194         virtual void visit( OffsetofExpr * old ) override final {
     2194        virtual void visit( const OffsetofExpr * old ) override final {
    21952195                this->node = visitBaseExpr( old,
    21962196                        new ast::OffsetofExpr(
    … …  
    22022202        }
    22032203
    2204         virtual void visit( OffsetPackExpr * old ) override final {
     2204        virtual void visit( const OffsetPackExpr * old ) override final {
    22052205                this->node = visitBaseExpr( old,
    22062206                        new ast::OffsetPackExpr(
    … …  
    22112211        }
    22122212
    2213         virtual void visit( LogicalExpr * old ) override final {
     2213        virtual void visit( const LogicalExpr * old ) override final {
    22142214                this->node = visitBaseExpr( old,
    22152215                        new ast::LogicalExpr(
    … …  
    22242224        }
    22252225
    2226         virtual void visit( ConditionalExpr * old ) override final {
     2226        virtual void visit( const ConditionalExpr * old ) override final {
    22272227                this->node = visitBaseExpr( old,
    22282228                        new ast::ConditionalExpr(
    … …  
    22352235        }
    22362236
    2237         virtual void visit( CommaExpr * old ) override final {
     2237        virtual void visit( const CommaExpr * old ) override final {
    22382238                this->node = visitBaseExpr( old,
    22392239                        new ast::CommaExpr(
    … …  
    22452245        }
    22462246
    2247         virtual void visit( TypeExpr * old ) override final {
     2247        virtual void visit( const TypeExpr * old ) override final {
    22482248                this->node = visitBaseExpr( old,
    22492249                        new ast::TypeExpr(
    … …  
    22542254        }
    22552255
    2256         virtual void visit( AsmExpr * old ) override final {
     2256        virtual void visit( const AsmExpr * old ) override final {
    22572257                this->node = visitBaseExpr( old,
    22582258                        new ast::AsmExpr(
    … …  
    22652265        }
    22662266
    2267         virtual void visit( ImplicitCopyCtorExpr * old ) override final {
     2267        virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
    22682268                auto rslt = new ast::ImplicitCopyCtorExpr(
    22692269                        old->location,
    … …  
    22742274        }
    22752275
    2276         virtual void visit( ConstructorExpr * old ) override final {
     2276        virtual void visit( const ConstructorExpr * old ) override final {
    22772277                this->node = visitBaseExpr( old,
    22782278                        new ast::ConstructorExpr(
    … …  
    22832283        }
    22842284
    2285         virtual void visit( CompoundLiteralExpr * old ) override final {
     2285        virtual void visit( const CompoundLiteralExpr * old ) override final {
    22862286                this->node = visitBaseExpr_SkipResultType( old,
    22872287                        new ast::CompoundLiteralExpr(
    … …  
    22932293        }
    22942294
    2295         virtual void visit( RangeExpr * old ) override final {
     2295        virtual void visit( const RangeExpr * old ) override final {
    22962296                this->node = visitBaseExpr( old,
    22972297                        new ast::RangeExpr(
    … …  
    23032303        }
    23042304
    2305         virtual void visit( UntypedTupleExpr * old ) override final {
     2305        virtual void visit( const UntypedTupleExpr * old ) override final {
    23062306                this->node = visitBaseExpr( old,
    23072307                        new ast::UntypedTupleExpr(
    … …  
    23122312        }
    23132313
    2314         virtual void visit( TupleExpr * old ) override final {
     2314        virtual void visit( const TupleExpr * old ) override final {
    23152315                this->node = visitBaseExpr( old,
    23162316                        new ast::TupleExpr(
    … …  
    23212321        }
    23222322
    2323         virtual void visit( TupleIndexExpr * old ) override final {
     2323        virtual void visit( const TupleIndexExpr * old ) override final {
    23242324                this->node = visitBaseExpr( old,
    23252325                        new ast::TupleIndexExpr(
    … …  
    23312331        }
    23322332
    2333         virtual void visit( TupleAssignExpr * old ) override final {
     2333        virtual void visit( const TupleAssignExpr * old ) override final {
    23342334                this->node = visitBaseExpr_SkipResultType( old,
    23352335                        new ast::TupleAssignExpr(
    … …  
    23412341        }
    23422342
    2343         virtual void visit( StmtExpr * old ) override final {
     2343        virtual void visit( const StmtExpr * old ) override final {
    23442344                auto rslt = new ast::StmtExpr(
    23452345                        old->location,
    … …  
    23522352        }
    23532353
    2354         virtual void visit( UniqueExpr * old ) override final {
     2354        virtual void visit( const UniqueExpr * old ) override final {
    23552355                auto rslt = new ast::UniqueExpr(
    23562356                        old->location,
    … …  
    23642364        }
    23652365
    2366         virtual void visit( UntypedInitExpr * old ) override final {
     2366        virtual void visit( const UntypedInitExpr * old ) override final {
    23672367                std::deque<ast::InitAlternative> initAlts;
    23682368                for (auto ia : old->initAlts) {
    … …  
    23812381        }
    23822382
    2383         virtual void visit( InitExpr * old ) override final {
     2383        virtual void visit( const InitExpr * old ) override final {
    23842384                this->node = visitBaseExpr( old,
    23852385                        new ast::InitExpr(
    … …  
    23912391        }
    23922392
    2393         virtual void visit( DeletedExpr * old ) override final {
     2393        virtual void visit( const DeletedExpr * old ) override final {
    23942394                this->node = visitBaseExpr( old,
    23952395                        new ast::DeletedExpr(
    … …  
    24032403        }
    24042404
    2405         virtual void visit( DefaultArgExpr * old ) override final {
     2405        virtual void visit( const DefaultArgExpr * old ) override final {
    24062406                this->node = visitBaseExpr( old,
    24072407                        new ast::DefaultArgExpr(
    … …  
    24122412        }
    24132413
    2414         virtual void visit( GenericExpr * old ) override final {
     2414        virtual void visit( const GenericExpr * old ) override final {
    24152415                std::vector<ast::GenericExpr::Association> associations;
    24162416                for (auto association : old->associations) {
    … …  
    24292429        }
    24302430
    2431         void visitType( Type * old, ast::Type * type ) {
     2431        void visitType( const 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( VoidType * old ) override final {
     2439        virtual void visit( const VoidType * old ) override final {
    24402440                visitType( old, new ast::VoidType{ cv( old ) } );
    24412441        }
    24422442
    2443         virtual void visit( BasicType * old ) override final {
     2443        virtual void visit( const 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( PointerType * old ) override final {
     2452        virtual void visit( const PointerType * old ) override final {
    24532453                visitType( old, new ast::PointerType{
    24542454                        GET_ACCEPT_1( base, Type ),
    … …  
    24602460        }
    24612461
    2462         virtual void visit( ArrayType * old ) override final {
     2462        virtual void visit( const ArrayType * old ) override final {
    24632463                visitType( old, new ast::ArrayType{
    24642464                        GET_ACCEPT_1( base, Type ),
    … …  
    24702470        }
    24712471
    2472         virtual void visit( ReferenceType * old ) override final {
     2472        virtual void visit( const ReferenceType * old ) override final {
    24732473                visitType( old, new ast::ReferenceType{
    24742474                        GET_ACCEPT_1( base, Type ),
    … …  
    24772477        }
    24782478
    2479         virtual void visit( QualifiedType * old ) override final {
     2479        virtual void visit( const QualifiedType * old ) override final {
    24802480                visitType( old, new ast::QualifiedType{
    24812481                        GET_ACCEPT_1( parent, Type ),
    … …  
    24852485        }
    24862486
    2487         virtual void visit( FunctionType * old ) override final {
     2487        virtual void visit( const FunctionType * old ) override final {
    24882488                auto ty = new ast::FunctionType {
    24892489                        (ast::ArgumentFlag)old->isVarArgs,
    … …  
    24962496        }
    24972497
    2498         void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
     2498        void postvisit( const 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( StructInstType * old ) override final {
     2505        virtual void visit( const StructInstType * old ) override final {
    25062506                ast::StructInstType * ty;
    25072507                if ( old->baseStruct ) {
    … …  
    25212521        }
    25222522
    2523         virtual void visit( UnionInstType * old ) override final {
     2523        virtual void visit( const UnionInstType * old ) override final {
    25242524                ast::UnionInstType * ty;
    25252525                if ( old->baseUnion ) {
    … …  
    25392539        }
    25402540
    2541         virtual void visit( EnumInstType * old ) override final {
     2541        virtual void visit( const EnumInstType * old ) override final {
    25422542                ast::EnumInstType * ty;
    25432543                if ( old->baseEnum ) {
    … …  
    25572557        }
    25582558
    2559         virtual void visit( TraitInstType * old ) override final {
     2559        virtual void visit( const TraitInstType * old ) override final {
    25602560                ast::TraitInstType * ty;
    25612561                if ( old->baseTrait ) {
    … …  
    25752575        }
    25762576
    2577         virtual void visit( TypeInstType * old ) override final {
     2577        virtual void visit( const TypeInstType * old ) override final {
    25782578                ast::TypeInstType * ty;
    25792579                if ( old->baseType ) {
    … …  
    25952595        }
    25962596
    2597         virtual void visit( TupleType * old ) override final {
     2597        virtual void visit( const TupleType * old ) override final {
    25982598                visitType( old, new ast::TupleType{
    25992599                        GET_ACCEPT_V( types, Type ),
    … …  
    26032603        }
    26042604
    2605         virtual void visit( TypeofType * old ) override final {
     2605        virtual void visit( const TypeofType * old ) override final {
    26062606                visitType( old, new ast::TypeofType{
    26072607                        GET_ACCEPT_1( expr, Expr ),
    … …  
    26112611        }
    26122612
    2613         virtual void visit( AttrType * ) override final {
     2613        virtual void visit( const AttrType * ) override final {
    26142614                assertf( false, "AttrType deprecated in new AST." );
    26152615        }
    26162616
    2617         virtual void visit( VarArgsType * old ) override final {
     2617        virtual void visit( const VarArgsType * old ) override final {
    26182618                visitType( old, new ast::VarArgsType{ cv( old ) } );
    26192619        }
    26202620
    2621         virtual void visit( ZeroType * old ) override final {
     2621        virtual void visit( const ZeroType * old ) override final {
    26222622                visitType( old, new ast::ZeroType{ cv( old ) } );
    26232623        }
    26242624
    2625         virtual void visit( OneType * old ) override final {
     2625        virtual void visit( const OneType * old ) override final {
    26262626                visitType( old, new ast::OneType{ cv( old ) } );
    26272627        }
    26282628
    2629         virtual void visit( GlobalScopeType * old ) override final {
     2629        virtual void visit( const GlobalScopeType * old ) override final {
    26302630                visitType( old, new ast::GlobalScopeType{} );
    26312631        }
    26322632
    2633         virtual void visit( Designation * old ) override final {
     2633        virtual void visit( const Designation * old ) override final {
    26342634                this->node = new ast::Designation(
    26352635                        old->location,
    … …  
    26382638        }
    26392639
    2640         virtual void visit( SingleInit * old ) override final {
     2640        virtual void visit( const SingleInit * old ) override final {
    26412641                this->node = new ast::SingleInit(
    26422642                        old->location,
    … …  
    26462646        }
    26472647
    2648         virtual void visit( ListInit * old ) override final {
     2648        virtual void visit( const ListInit * old ) override final {
    26492649                this->node = new ast::ListInit(
    26502650                        old->location,
    … …  
    26552655        }
    26562656
    2657         virtual void visit( ConstructorInit * old ) override final {
     2657        virtual void visit( const ConstructorInit * old ) override final {
    26582658                this->node = new ast::ConstructorInit(
    26592659                        old->location,
    … …  
    26642664        }
    26652665
    2666         virtual void visit( Constant * ) override final {
     2666        virtual void visit( const 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( Attribute * old ) override final {
     2672        virtual void visit( const Attribute * old ) override final {
    26732673                this->node = new ast::Attribute(
    26742674                        old->name,
    … …  
    26772677        }
    26782678
    2679         virtual void visit( AttrExpr * ) override final {
     2679        virtual void visit( const AttrExpr * ) override final {
    26802680                assertf( false, "AttrExpr deprecated in new AST." );
    26812681        }

  • src/AST/Expr.hpp

    ree6dbae r7870799  
    4747
    4848        ParamEntry() : decl( 0 ), declptr( nullptr ), actualType( nullptr ), formalType( nullptr ), expr( nullptr ) {}
    49         ParamEntry( 
    50                 UniqueId id, const Decl * declptr, const Type * actual, const Type * formal, 
     49        ParamEntry(
     50                UniqueId id, const Decl * declptr, const Type * actual, const Type * formal,
    5151                const Expr * e )
    5252        : decl( id ), declptr( declptr ), actualType( actual ), formalType( formal ), expr( e ) {}
    … …  
    112112                        case Empty: new(&data.resnSlots) ResnSlots{}; mode = Slots; // fallthrough
    113113                        case Slots: return data.resnSlots;
    114                         case Params: assert(!"Cannot return to resnSlots from Params");
     114                        case Params: assertf(false, "Cannot return to resnSlots from Params"); abort();
    115115                        }
    116                         return *((ResnSlots*)nullptr);
    117116                }
    118117
    … …  
    121120                                return data.resnSlots;
    122121                        }
    123                         assert(!"Mode was not already resnSlots");
    124                         return *((ResnSlots*)nullptr);
     122                        assertf(false, "Mode was not already resnSlots");
     123                        abort();
    125124                }
    126125
    … …  
    131130                        case Params: return data.inferParams;
    132131                        }
    133                         assert(!"unreachable");
    134                         return *((InferredParams*)nullptr);
     132                        assertf(false, "unreachable");
    135133                }
    136134
    … …  
    139137                                return data.inferParams;
    140138                        }
    141                         assert(!"Mode was not already Params");
    142                         return *((InferredParams*)nullptr);
     139                        assertf(false, "Mode was not already Params");
     140                        abort();
    143141                }
    144142
    145143                void set_inferParams( InferredParams && ps ) {
    146144                        switch(mode) {
    147                         case Slots: 
     145                        case Slots:
    148146                                data.resnSlots.~ResnSlots();
    149147                                // fallthrough
    150                         case Empty: 
     148                        case Empty:
    151149                                new(&data.inferParams) InferredParams{ std::move( ps ) };
    152150                                mode = Params;
    … …  
    172170                                        data.inferParams[p.first] = std::move(p.second);
    173171                                }
    174                         } else assert(!"invalid mode");
     172                        } else assertf(false, "invalid mode");
    175173                }
    176174        };
    … …  
    384382
    385383        ConstantExpr(
    386                 const CodeLocation & loc, const Type * ty, const std::string & r, 
     384                const CodeLocation & loc, const Type * ty, const std::string & r,
    387385                        std::optional<unsigned long long> i )
    388386        : Expr( loc, ty ), rep( r ), ival( i ) {}
Note: See TracChangeset for help on using the changeset viewer.