Changeset 7870799 for src/SynTree


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/SynTree
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Attribute.h

    ree6dbae r7870799  
    5050        Attribute * clone() const override { return new Attribute( *this ); }
    5151        virtual void accept( Visitor & v ) override { v.visit( this ); }
     52        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    5253        virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    5354        virtual void print( std::ostream & os, Indenter indent = {} ) const override;

  • src/SynTree/BaseSyntaxNode.h

    ree6dbae r7870799  
    3232        BaseSyntaxNode( const BaseSyntaxNode & o ) : location(o.location) { ++*new_nodes; }
    3333        BaseSyntaxNode & operator=( const BaseSyntaxNode & ) = default;
    34        
     34
    3535        virtual ~BaseSyntaxNode() {}
    3636
    3737        virtual BaseSyntaxNode * clone() const = 0;
    3838        virtual void accept( Visitor & v ) = 0;
     39        virtual void accept( Visitor & v ) const = 0;
    3940        virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
    4041        /// Notes:

  • src/SynTree/Constant.h

    ree6dbae r7870799  
    3333        virtual ~Constant();
    3434
    35         virtual Constant * clone() const { return new Constant( *this ); }
     35        virtual Constant * clone() const override { return new Constant( *this ); }
    3636
    3737        Type * get_type() { return type; }
    … …  
    5151        static Constant null( Type * ptrtype = nullptr );
    5252
    53         virtual void accept( Visitor & v ) { v.visit( this ); }
    54         virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    55         virtual void print( std::ostream & os, Indenter indent = 0 ) const;
    56   private:
     53        virtual void accept( Visitor & v ) override { v.visit( this ); }
     54        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     55        virtual Constant * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     56        virtual void print( std::ostream & os, Indenter indent = 0 ) const override;
     57
    5758        Type * type;
    5859        std::string rep;
    5960        std::optional<unsigned long long> ival;
    60 
    61         friend class ConverterOldToNew;
    6261};
    6362

  • src/SynTree/Declaration.h

    ree6dbae r7870799  
    6363        void fixUniqueId( void );
    6464        virtual Declaration *clone() const override = 0;
    65         virtual void accept( Visitor &v ) override = 0;
     65        virtual void accept( Visitor & v ) override = 0;
     66        virtual void accept( Visitor & v ) const override = 0;
    6667        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
    6768        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
    … …  
    139140
    140141        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
    141         virtual void accept( Visitor &v ) override { v.visit( this ); }
     142        virtual void accept( Visitor & v ) override { v.visit( this ); }
     143        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    142144        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    143145        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    169171
    170172        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
    171         virtual void accept( Visitor &v ) override { v.visit( this ); }
     173        virtual void accept( Visitor & v ) override { v.visit( this ); }
     174        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    172175        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    173176        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    238241
    239242        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
    240         virtual void accept( Visitor &v ) override { v.visit( this ); }
     243        virtual void accept( Visitor & v ) override { v.visit( this ); }
     244        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    241245        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    242246        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    256260
    257261        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
    258         virtual void accept( Visitor &v ) override { v.visit( this ); }
     262        virtual void accept( Visitor & v ) override { v.visit( this ); }
     263        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    259264        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    260265  private:
    … …  
    300305
    301306        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
    302         virtual void accept( Visitor &v ) override { v.visit( this ); }
     307        virtual void accept( Visitor & v ) override { v.visit( this ); }
     308        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    303309        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    304310        DeclarationNode::Aggregate kind;
    … …  
    314320
    315321        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
    316         virtual void accept( Visitor &v ) override { v.visit( this ); }
     322        virtual void accept( Visitor & v ) override { v.visit( this ); }
     323        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    317324        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    318325  private:
    … …  
    329336
    330337        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
    331         virtual void accept( Visitor &v ) override { v.visit( this ); }
     338        virtual void accept( Visitor & v ) override { v.visit( this ); }
     339        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    332340        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    333341  private:
    … …  
    345353
    346354        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
    347         virtual void accept( Visitor &v ) override { v.visit( this ); }
     355        virtual void accept( Visitor & v ) override { v.visit( this ); }
     356        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    348357        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    349358  private:
    … …  
    363372
    364373        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
    365         virtual void accept( Visitor &v ) override { v.visit( this ); }
     374        virtual void accept( Visitor & v ) override { v.visit( this ); }
     375        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    366376        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    367377        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    379389
    380390        virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
    381         virtual void accept( Visitor &v ) override { v.visit( this ); }
     391        virtual void accept( Visitor & v ) override { v.visit( this ); }
     392        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    382393        virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    383394        virtual void print( std::ostream &os, Indenter indent = {} ) const override;

  • src/SynTree/Expression.h

    ree6dbae r7870799  
    8282        virtual Expression * clone() const override = 0;
    8383        virtual void accept( Visitor & v ) override = 0;
     84        virtual void accept( Visitor & v ) const override = 0;
    8485        virtual Expression * acceptMutator( Mutator & m ) override = 0;
    8586        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    101102        std::list<Expression *>& get_args() { return args; }
    102103
    103         virtual ApplicationExpr * clone() const { return new ApplicationExpr( * this ); }
    104         virtual void accept( Visitor & v ) { v.visit( this ); }
    105         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    106         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     104        virtual ApplicationExpr * clone() const override { return new ApplicationExpr( * this ); }
     105        virtual void accept( Visitor & v ) override { v.visit( this ); }
     106        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     107        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     108        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    107109};
    108110
    … …  
    129131        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
    130132
    131         virtual UntypedExpr * clone() const { return new UntypedExpr( * this ); }
    132         virtual void accept( Visitor & v ) { v.visit( this ); }
    133         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    134         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     133        virtual UntypedExpr * clone() const override { return new UntypedExpr( * this ); }
     134        virtual void accept( Visitor & v ) override { v.visit( this ); }
     135        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     136        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     137        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    135138};
    136139
    … …  
    147150        void set_name( std::string newValue ) { name = newValue; }
    148151
    149         virtual NameExpr * clone() const { return new NameExpr( * this ); }
    150         virtual void accept( Visitor & v ) { v.visit( this ); }
    151         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    152         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     152        virtual NameExpr * clone() const override { return new NameExpr( * this ); }
     153        virtual void accept( Visitor & v ) override { v.visit( this ); }
     154        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     155        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     156        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    153157};
    154158
    … …  
    168172        void set_arg(Expression * newValue ) { arg = newValue; }
    169173
    170         virtual AddressExpr * clone() const { return new AddressExpr( * this ); }
    171         virtual void accept( Visitor & v ) { v.visit( this ); }
    172         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    173         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     174        virtual AddressExpr * clone() const override { return new AddressExpr( * this ); }
     175        virtual void accept( Visitor & v ) override { v.visit( this ); }
     176        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     177        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     178        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    174179};
    175180
    … …  
    184189        virtual ~LabelAddressExpr();
    185190
    186         virtual LabelAddressExpr * clone() const { return new LabelAddressExpr( * this ); }
    187         virtual void accept( Visitor & v ) { v.visit( this ); }
    188         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    189         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     191        virtual LabelAddressExpr * clone() const override { return new LabelAddressExpr( * this ); }
     192        virtual void accept( Visitor & v ) override { v.visit( this ); }
     193        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     194        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     195        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    190196};
    191197
    … …  
    205211        void set_arg( Expression * newValue ) { arg = newValue; }
    206212
    207         virtual CastExpr * clone() const { return new CastExpr( * this ); }
    208         virtual void accept( Visitor & v ) { v.visit( this ); }
    209         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    210         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     213        virtual CastExpr * clone() const override { return new CastExpr( * this ); }
     214        virtual void accept( Visitor & v ) override { v.visit( this ); }
     215        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     216        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     217        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    211218};
    212219
    … …  
    225232        const std::string & targetString() const;
    226233
    227         virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
    228         virtual void accept( Visitor & v ) { v.visit( this ); }
    229         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    230         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     234        virtual KeywordCastExpr * clone() const override { return new KeywordCastExpr( * this ); }
     235        virtual void accept( Visitor & v ) override { v.visit( this ); }
     236        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     237        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     238        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    231239};
    232240
    … …  
    243251        void set_arg( Expression * newValue ) { arg = newValue; }
    244252
    245         virtual VirtualCastExpr * clone() const { return new VirtualCastExpr( * this ); }
    246         virtual void accept( Visitor & v ) { v.visit( this ); }
    247         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    248         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     253        virtual VirtualCastExpr * clone() const override { return new VirtualCastExpr( * this ); }
     254        virtual void accept( Visitor & v ) override { v.visit( this ); }
     255        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     256        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     257        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    249258};
    250259
    … …  
    264273        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    265274
    266         virtual UntypedMemberExpr * clone() const { return new UntypedMemberExpr( * this ); }
    267         virtual void accept( Visitor & v ) { v.visit( this ); }
    268         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    269         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     275        virtual UntypedMemberExpr * clone() const override { return new UntypedMemberExpr( * this ); }
     276        virtual void accept( Visitor & v ) override { v.visit( this ); }
     277        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     278        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     279        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    270280};
    271281
    … …  
    286296        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    287297
    288         virtual MemberExpr * clone() const { return new MemberExpr( * this ); }
    289         virtual void accept( Visitor & v ) { v.visit( this ); }
    290         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    291         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     298        virtual MemberExpr * clone() const override { return new MemberExpr( * this ); }
     299        virtual void accept( Visitor & v ) override { v.visit( this ); }
     300        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     301        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     302        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    292303};
    293304
    … …  
    308319        static VariableExpr * functionPointer( FunctionDecl * decl );
    309320
    310         virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
    311         virtual void accept( Visitor & v ) { v.visit( this ); }
    312         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    313         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     321        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
     322        virtual void accept( Visitor & v ) override { v.visit( this ); }
     323        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     324        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     325        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    314326};
    315327
    … …  
    329341        long long int intValue() const;
    330342
    331         virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }
    332         virtual void accept( Visitor & v ) { v.visit( this ); }
    333         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    334         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     343        virtual ConstantExpr * clone() const override { return new ConstantExpr( * this ); }
     344        virtual void accept( Visitor & v ) override { v.visit( this ); }
     345        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     346        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     347        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    335348};
    336349
    … …  
    354367        void set_isType( bool newValue ) { isType = newValue; }
    355368
    356         virtual SizeofExpr * clone() const { return new SizeofExpr( * this ); }
    357         virtual void accept( Visitor & v ) { v.visit( this ); }
    358         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    359         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     369        virtual SizeofExpr * clone() const override { return new SizeofExpr( * this ); }
     370        virtual void accept( Visitor & v ) override { v.visit( this ); }
     371        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     372        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     373        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    360374};
    361375
    … …  
    379393        void set_isType( bool newValue ) { isType = newValue; }
    380394
    381         virtual AlignofExpr * clone() const { return new AlignofExpr( * this ); }
    382         virtual void accept( Visitor & v ) { v.visit( this ); }
    383         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    384         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     395        virtual AlignofExpr * clone() const override { return new AlignofExpr( * this ); }
     396        virtual void accept( Visitor & v ) override { v.visit( this ); }
     397        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     398        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     399        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    385400};
    386401
    … …  
    400415        void set_type( Type * newValue ) { type = newValue; }
    401416
    402         virtual UntypedOffsetofExpr * clone() const { return new UntypedOffsetofExpr( * this ); }
    403         virtual void accept( Visitor & v ) { v.visit( this ); }
    404         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    405         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     417        virtual UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr( * this ); }
     418        virtual void accept( Visitor & v ) override { v.visit( this ); }
     419        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     420        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     421        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    406422};
    407423
    … …  
    421437        void set_member( DeclarationWithType * newValue ) { member = newValue; }
    422438
    423         virtual OffsetofExpr * clone() const { return new OffsetofExpr( * this ); }
    424         virtual void accept( Visitor & v ) { v.visit( this ); }
    425         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    426         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     439        virtual OffsetofExpr * clone() const override { return new OffsetofExpr( * this ); }
     440        virtual void accept( Visitor & v ) override { v.visit( this ); }
     441        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     442        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     443        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    427444};
    428445
    … …  
    439456        void set_type( StructInstType * newValue ) { type = newValue; }
    440457
    441         virtual OffsetPackExpr * clone() const { return new OffsetPackExpr( * this ); }
    442         virtual void accept( Visitor & v ) { v.visit( this ); }
    443         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    444         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     458        virtual OffsetPackExpr * clone() const override { return new OffsetPackExpr( * this ); }
     459        virtual void accept( Visitor & v ) override { v.visit( this ); }
     460        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     461        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     462        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    445463};
    446464
    … …  
    467485        void set_isType( bool newValue ) { isType = newValue; }
    468486
    469         virtual AttrExpr * clone() const { return new AttrExpr( * this ); }
    470         virtual void accept( Visitor & v ) { v.visit( this ); }
    471         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    472         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     487        virtual AttrExpr * clone() const override { return new AttrExpr( * this ); }
     488        virtual void accept( Visitor & v ) override { v.visit( this ); }
     489        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     490        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     491        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    473492};
    474493
    … …  
    489508        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    490509
    491         virtual LogicalExpr * clone() const { return new LogicalExpr( * this ); }
    492         virtual void accept( Visitor & v ) { v.visit( this ); }
    493         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    494         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     510        virtual LogicalExpr * clone() const override { return new LogicalExpr( * this ); }
     511        virtual void accept( Visitor & v ) override { v.visit( this ); }
     512        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     513        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     514        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    495515
    496516  private:
    … …  
    516536        void set_arg3( Expression * newValue ) { arg3 = newValue; }
    517537
    518         virtual ConditionalExpr * clone() const { return new ConditionalExpr( * this ); }
    519         virtual void accept( Visitor & v ) { v.visit( this ); }
    520         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    521         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     538        virtual ConditionalExpr * clone() const override { return new ConditionalExpr( * this ); }
     539        virtual void accept( Visitor & v ) override { v.visit( this ); }
     540        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     541        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     542        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    522543};
    523544
    … …  
    537558        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    538559
    539         virtual CommaExpr * clone() const { return new CommaExpr( * this ); }
    540         virtual void accept( Visitor & v ) { v.visit( this ); }
    541         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    542         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     560        virtual CommaExpr * clone() const override { return new CommaExpr( * this ); }
     561        virtual void accept( Visitor & v ) override { v.visit( this ); }
     562        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     563        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     564        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    543565};
    544566
    … …  
    555577        void set_type( Type * newValue ) { type = newValue; }
    556578
    557         virtual TypeExpr * clone() const { return new TypeExpr( * this ); }
    558         virtual void accept( Visitor & v ) { v.visit( this ); }
    559         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    560         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     579        virtual TypeExpr * clone() const override { return new TypeExpr( * this ); }
     580        virtual void accept( Visitor & v ) override { v.visit( this ); }
     581        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     582        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     583        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    561584};
    562585
    … …  
    581604        void set_operand( Expression * newValue ) { operand = newValue; }
    582605
    583         virtual AsmExpr * clone() const { return new AsmExpr( * this ); }
    584         virtual void accept( Visitor & v ) { v.visit( this ); }
    585         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    586         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     606        virtual AsmExpr * clone() const override { return new AsmExpr( * this ); }
     607        virtual void accept( Visitor & v ) override { v.visit( this ); }
     608        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     609        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     610        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    587611
    588612        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
    … …  
    599623        virtual ~ImplicitCopyCtorExpr();
    600624
    601         virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
    602         virtual void accept( Visitor & v ) { v.visit( this ); }
    603         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    604         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     625        virtual ImplicitCopyCtorExpr * clone() const override { return new ImplicitCopyCtorExpr( * this ); }
     626        virtual void accept( Visitor & v ) override { v.visit( this ); }
     627        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     628        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     629        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    605630};
    606631
    … …  
    617642        void set_callExpr( Expression * newValue ) { callExpr = newValue; }
    618643
    619         virtual ConstructorExpr * clone() const { return new ConstructorExpr( * this ); }
    620         virtual void accept( Visitor & v ) { v.visit( this ); }
    621         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    622         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     644        virtual ConstructorExpr * clone() const override { return new ConstructorExpr( * this ); }
     645        virtual void accept( Visitor & v ) override { v.visit( this ); }
     646        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     647        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     648        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    623649};
    624650
    … …  
    635661        void set_initializer( Initializer * i ) { initializer = i; }
    636662
    637         virtual CompoundLiteralExpr * clone() const { return new CompoundLiteralExpr( * this ); }
    638         virtual void accept( Visitor & v ) { v.visit( this ); }
    639         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    640         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     663        virtual CompoundLiteralExpr * clone() const override { return new CompoundLiteralExpr( * this ); }
     664        virtual void accept( Visitor & v ) override { v.visit( this ); }
     665        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     666        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     667        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    641668};
    642669
    … …  
    654681        RangeExpr * set_high( Expression * high ) { RangeExpr::high = high; return this; }
    655682
    656         virtual RangeExpr * clone() const { return new RangeExpr( * this ); }
    657         virtual void accept( Visitor & v ) { v.visit( this ); }
    658         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    659         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     683        virtual RangeExpr * clone() const override { return new RangeExpr( * this ); }
     684        virtual void accept( Visitor & v ) override { v.visit( this ); }
     685        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     686        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     687        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    660688};
    661689
    … …  
    671699        std::list<Expression*>& get_exprs() { return exprs; }
    672700
    673         virtual UntypedTupleExpr * clone() const { return new UntypedTupleExpr( * this ); }
    674         virtual void accept( Visitor & v ) { v.visit( this ); }
    675         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    676         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     701        virtual UntypedTupleExpr * clone() const override { return new UntypedTupleExpr( * this ); }
     702        virtual void accept( Visitor & v ) override { v.visit( this ); }
     703        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     704        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     705        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    677706};
    678707
    … …  
    688717        std::list<Expression*>& get_exprs() { return exprs; }
    689718
    690         virtual TupleExpr * clone() const { return new TupleExpr( * this ); }
    691         virtual void accept( Visitor & v ) { v.visit( this ); }
    692         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    693         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     719        virtual TupleExpr * clone() const override { return new TupleExpr( * this ); }
     720        virtual void accept( Visitor & v ) override { v.visit( this ); }
     721        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     722        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     723        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    694724};
    695725
    … …  
    709739        TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
    710740
    711         virtual TupleIndexExpr * clone() const { return new TupleIndexExpr( * this ); }
    712         virtual void accept( Visitor & v ) { v.visit( this ); }
    713         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    714         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     741        virtual TupleIndexExpr * clone() const override { return new TupleIndexExpr( * this ); }
     742        virtual void accept( Visitor & v ) override { v.visit( this ); }
     743        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     744        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     745        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    715746};
    716747
    … …  
    727758        StmtExpr * get_stmtExpr() const { return stmtExpr; }
    728759
    729         virtual TupleAssignExpr * clone() const { return new TupleAssignExpr( * this ); }
    730         virtual void accept( Visitor & v ) { v.visit( this ); }
    731         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    732         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     760        virtual TupleAssignExpr * clone() const override { return new TupleAssignExpr( * this ); }
     761        virtual void accept( Visitor & v ) override { v.visit( this ); }
     762        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     763        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     764        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    733765
    734766        friend class ConverterNewToOld;
    … …  
    760792        std::list< Expression * > & get_dtors() { return dtors; }
    761793
    762         virtual StmtExpr * clone() const { return new StmtExpr( * this ); }
    763         virtual void accept( Visitor & v ) { v.visit( this ); }
    764         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    765         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     794        virtual StmtExpr * clone() const override { return new StmtExpr( * this ); }
     795        virtual void accept( Visitor & v ) override { v.visit( this ); }
     796        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     797        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     798        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    766799};
    767800
    … …  
    787820        int get_id() const { return id; }
    788821
    789         virtual UniqueExpr * clone() const { return new UniqueExpr( * this ); }
    790         virtual void accept( Visitor & v ) { v.visit( this ); }
    791         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    792         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     822        virtual UniqueExpr * clone() const override { return new UniqueExpr( * this ); }
     823        virtual void accept( Visitor & v ) override { v.visit( this ); }
     824        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     825        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     826        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    793827
    794828private:
    … …  
    821855        std::list<InitAlternative> & get_initAlts() { return initAlts; }
    822856
    823         virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
    824         virtual void accept( Visitor & v ) { v.visit( this ); }
    825         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    826         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     857        virtual UntypedInitExpr * clone() const override { return new UntypedInitExpr( * this ); }
     858        virtual void accept( Visitor & v ) override { v.visit( this ); }
     859        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     860        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     861        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    827862};
    828863
    … …  
    842877        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
    843878
    844         virtual InitExpr * clone() const { return new InitExpr( * this ); }
    845         virtual void accept( Visitor & v ) { v.visit( this ); }
    846         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    847         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     879        virtual InitExpr * clone() const override { return new InitExpr( * this ); }
     880        virtual void accept( Visitor & v ) override { v.visit( this ); }
     881        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     882        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     883        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    848884};
    849885
    … …  
    858894        ~DeletedExpr();
    859895
    860         virtual DeletedExpr * clone() const { return new DeletedExpr( * this ); }
    861         virtual void accept( Visitor & v ) { v.visit( this ); }
    862         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    863         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     896        virtual DeletedExpr * clone() const override { return new DeletedExpr( * this ); }
     897        virtual void accept( Visitor & v ) override { v.visit( this ); }
     898        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     899        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     900        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    864901};
    865902
    … …  
    873910        ~DefaultArgExpr();
    874911
    875         virtual DefaultArgExpr * clone() const { return new DefaultArgExpr( * this ); }
    876         virtual void accept( Visitor & v ) { v.visit( this ); }
    877         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    878         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     912        virtual DefaultArgExpr * clone() const override { return new DefaultArgExpr( * this ); }
     913        virtual void accept( Visitor & v ) override { v.visit( this ); }
     914        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     915        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     916        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    879917};
    880918
    … …  
    901939        virtual ~GenericExpr();
    902940
    903         virtual GenericExpr * clone() const { return new GenericExpr( * this ); }
    904         virtual void accept( Visitor & v ) { v.visit( this ); }
    905         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    906         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     941        virtual GenericExpr * clone() const override { return new GenericExpr( * this ); }
     942        virtual void accept( Visitor & v ) override { v.visit( this ); }
     943        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     944        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     945        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    907946};
    908947

  • src/SynTree/Initializer.h

    ree6dbae r7870799  
    3838
    3939        virtual Designation * clone() const override { return new Designation( *this ); };
    40         virtual void accept( Visitor &v ) override { v.visit( this ); }
     40        virtual void accept( Visitor & v ) override { v.visit( this ); }
     41        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    4142        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
    4243        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    5253        virtual ~Initializer();
    5354
    54         bool get_maybeConstructed() { return maybeConstructed; }
     55        bool get_maybeConstructed() const { return maybeConstructed; }
    5556
    5657        virtual Initializer *clone() const override = 0;
    57         virtual void accept( Visitor &v ) override = 0;
     58        virtual void accept( Visitor & v ) override = 0;
     59        virtual void accept( Visitor & v ) const override = 0;
    5860        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
    5961        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
    … …  
    7678
    7779        virtual SingleInit *clone() const override { return new SingleInit( *this); }
    78         virtual void accept( Visitor &v ) override { v.visit( this ); }
     80        virtual void accept( Visitor & v ) override { v.visit( this ); }
     81        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    7982        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    8083        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    104107
    105108        virtual ListInit *clone() const override { return new ListInit( *this ); }
    106         virtual void accept( Visitor &v ) override { v.visit( this ); }
     109        virtual void accept( Visitor & v ) override { v.visit( this ); }
     110        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    107111        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    108112        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    133137
    134138        ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
    135         virtual void accept( Visitor &v ) override { v.visit( this ); }
     139        virtual void accept( Visitor & v ) override { v.visit( this ); }
     140        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    136141        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    137142        virtual void print( std::ostream &os, Indenter indent = {} ) const override;

  • src/SynTree/Statement.h

    ree6dbae r7870799  
    4545        virtual Statement * clone() const override = 0;
    4646        virtual void accept( Visitor & v ) override = 0;
     47        virtual void accept( Visitor & v ) const override = 0;
    4748        virtual Statement * acceptMutator( Mutator & m ) override = 0;
    4849        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    6465        virtual CompoundStmt * clone() const override { return new CompoundStmt( *this ); }
    6566        virtual void accept( Visitor & v ) override { v.visit( this ); }
     67        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    6668        virtual CompoundStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    6769        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    7476        virtual NullStmt * clone() const override { return new NullStmt( *this ); }
    7577        virtual void accept( Visitor & v ) override { v.visit( this ); }
     78        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    7679        virtual NullStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    7780        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    9194        virtual ExprStmt * clone() const override { return new ExprStmt( *this ); }
    9295        virtual void accept( Visitor & v ) override { v.visit( this ); }
     96        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    9397        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    9498        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    120124        void set_gotolabels( const std::list<Label> & newValue ) { gotolabels = newValue; }
    121125
    122         virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
    123         virtual void accept( Visitor & v ) { v.visit( this ); }
    124         virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    125         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     126        virtual AsmStmt * clone() const override { return new AsmStmt( *this ); }
     127        virtual void accept( Visitor & v ) override { v.visit( this ); }
     128        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     129        virtual Statement * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     130        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    126131};
    127132
    … …  
    133138        virtual ~DirectiveStmt(){}
    134139
    135         virtual DirectiveStmt * clone() const { return new DirectiveStmt( *this ); }
    136         virtual void accept( Visitor & v ) { v.visit( this ); }
    137         virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
    138         virtual void print( std::ostream & os, Indenter indent = {} ) const;
     140        virtual DirectiveStmt * clone() const override { return new DirectiveStmt( *this ); }
     141        virtual void accept( Visitor & v ) override { v.visit( this ); }
     142        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     143        virtual Statement * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     144        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    139145};
    140146
    … …  
    161167        virtual IfStmt * clone() const override { return new IfStmt( *this ); }
    162168        virtual void accept( Visitor & v ) override { v.visit( this ); }
     169        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    163170        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    164171        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    180187
    181188        virtual void accept( Visitor & v ) override { v.visit( this ); }
     189        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    182190        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    183191
    … …  
    208216
    209217        virtual void accept( Visitor & v ) override { v.visit( this ); }
     218        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    210219        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    211220
    … …  
    236245        virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
    237246        virtual void accept( Visitor & v ) override { v.visit( this ); }
     247        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    238248        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    239249        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    261271        virtual ForStmt * clone() const override { return new ForStmt( *this ); }
    262272        virtual void accept( Visitor & v ) override { v.visit( this ); }
     273        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    263274        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    264275        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    290301        virtual BranchStmt * clone() const override { return new BranchStmt( *this ); }
    291302        virtual void accept( Visitor & v ) override { v.visit( this ); }
     303        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    292304        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    293305        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    309321        virtual ReturnStmt * clone() const override { return new ReturnStmt( *this ); }
    310322        virtual void accept( Visitor & v ) override { v.visit( this ); }
     323        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    311324        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    312325        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    333346        virtual ThrowStmt * clone() const override { return new ThrowStmt( *this ); }
    334347        virtual void accept( Visitor & v ) override { v.visit( this ); }
     348        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    335349        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    336350        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    356370        virtual TryStmt * clone() const override { return new TryStmt( *this ); }
    357371        virtual void accept( Visitor & v ) override { v.visit( this ); }
     372        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    358373        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    359374        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    384399        virtual CatchStmt * clone() const override { return new CatchStmt( *this ); }
    385400        virtual void accept( Visitor & v ) override { v.visit( this ); }
     401        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    386402        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    387403        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    401417        virtual FinallyStmt * clone() const override { return new FinallyStmt( *this ); }
    402418        virtual void accept( Visitor & v ) override { v.visit( this ); }
     419        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    403420        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    404421        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    438455        virtual WaitForStmt * clone() const override { return new WaitForStmt( *this ); }
    439456        virtual void accept( Visitor & v ) override { v.visit( this ); }
     457        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    440458        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    441459        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    454472        virtual WithStmt * clone() const override { return new WithStmt( *this ); }
    455473        virtual void accept( Visitor & v ) override { v.visit( this ); }
     474        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    456475        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    457476        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    473492        virtual DeclStmt * clone() const override { return new DeclStmt( *this ); }
    474493        virtual void accept( Visitor & v ) override { v.visit( this ); }
     494        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    475495        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    476496        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    494514        virtual ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt( *this ); }
    495515        virtual void accept( Visitor & v ) override { v.visit( this ); }
     516        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    496517        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    497518        virtual void print( std::ostream & os, Indenter indent = {} ) const override;

  • src/SynTree/Type.h

    ree6dbae r7870799  
    144144
    145145        Qualifiers & get_qualifiers() { return tq; }
    146         bool get_const() { return tq.is_const; }
    147         bool get_volatile() { return tq.is_volatile; }
    148         bool get_restrict() { return tq.is_restrict; }
    149         bool get_lvalue() { return tq.is_lvalue; }
    150         bool get_mutex() { return tq.is_mutex; }
    151         bool get_atomic() { return tq.is_atomic; }
     146        bool get_const() const { return tq.is_const; }
     147        bool get_volatile() const { return tq.is_volatile; }
     148        bool get_restrict() const { return tq.is_restrict; }
     149        bool get_lvalue() const { return tq.is_lvalue; }
     150        bool get_mutex() const { return tq.is_mutex; }
     151        bool get_atomic() const { return tq.is_atomic; }
    152152        void set_const( bool newValue ) { tq.is_const = newValue; }
    153153        void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
    … …  
    184184        virtual Type *clone() const = 0;
    185185        virtual void accept( Visitor & v ) = 0;
     186        virtual void accept( Visitor & v ) const = 0;
    186187        virtual Type *acceptMutator( Mutator & m ) = 0;
    187188        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    … …  
    201202        virtual VoidType *clone() const override { return new VoidType( *this ); }
    202203        virtual void accept( Visitor & v ) override { v.visit( this ); }
     204        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    203205        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    204206        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    259261        virtual BasicType *clone() const override { return new BasicType( *this ); }
    260262        virtual void accept( Visitor & v ) override { v.visit( this ); }
     263        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    261264        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    262265        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    294297        virtual PointerType *clone() const override { return new PointerType( *this ); }
    295298        virtual void accept( Visitor & v ) override { v.visit( this ); }
     299        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    296300        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    297301        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    325329        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
    326330        virtual void accept( Visitor & v ) override { v.visit( this ); }
     331        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    327332        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    328333        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    340345        virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
    341346        virtual void accept( Visitor & v ) override { v.visit( this ); }
     347        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    342348        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    343349        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    366372        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
    367373        virtual void accept( Visitor & v ) override { v.visit( this ); }
     374        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    368375        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    369376        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    395402        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
    396403        virtual void accept( Visitor & v ) override { v.visit( this ); }
     404        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    397405        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    398406        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    455463        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
    456464        virtual void accept( Visitor & v ) override { v.visit( this ); }
     465        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    457466        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    458467
    … …  
    492501        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
    493502        virtual void accept( Visitor & v ) override { v.visit( this ); }
     503        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    494504        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    495505
    … …  
    519529        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
    520530        virtual void accept( Visitor & v ) override { v.visit( this ); }
     531        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    521532        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    522533
    … …  
    542553        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
    543554        virtual void accept( Visitor & v ) override { v.visit( this ); }
     555        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    544556        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    545557  private:
    … …  
    569581        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
    570582        virtual void accept( Visitor & v ) override { v.visit( this ); }
     583        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    571584        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    572585        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    606619        virtual TupleType *clone() const override { return new TupleType( *this ); }
    607620        virtual void accept( Visitor & v ) override { v.visit( this ); }
     621        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    608622        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    609623        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    616630
    617631        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    618         TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, 
     632        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
    619633                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    620634        TypeofType( const TypeofType& );
    … …  
    628642        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
    629643        virtual void accept( Visitor & v ) override { v.visit( this ); }
     644        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    630645        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    631646        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    657672        virtual AttrType *clone() const override { return new AttrType( *this ); }
    658673        virtual void accept( Visitor & v ) override { v.visit( this ); }
     674        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    659675        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    660676        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    671687        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
    672688        virtual void accept( Visitor & v ) override { v.visit( this ); }
     689        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    673690        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    674691        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    683700        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
    684701        virtual void accept( Visitor & v ) override { v.visit( this ); }
     702        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    685703        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    686704        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    695713        virtual OneType *clone() const override { return new OneType( *this ); }
    696714        virtual void accept( Visitor & v ) override { v.visit( this ); }
     715        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    697716        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    698717        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    705724        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
    706725        virtual void accept( Visitor & v ) override { v.visit( this ); }
     726        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    707727        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    708728        virtual void print( std::ostream & os, Indenter indent = {} ) const override;

  • src/SynTree/Visitor.h

    ree6dbae r7870799  
    2727        // of the given syntax node, but performs no other action.
    2828
    29         virtual void visit( ObjectDecl * objectDecl ) = 0;
    30         virtual void visit( FunctionDecl * functionDecl ) = 0;
    31         virtual void visit( StructDecl * aggregateDecl ) = 0;
    32         virtual void visit( UnionDecl * aggregateDecl ) = 0;
    33         virtual void visit( EnumDecl * aggregateDecl ) = 0;
    34         virtual void visit( TraitDecl * aggregateDecl ) = 0;
    35         virtual void visit( TypeDecl * typeDecl ) = 0;
    36         virtual void visit( TypedefDecl * typeDecl ) = 0;
    37         virtual void visit( AsmDecl * asmDecl ) = 0;
    38         virtual void visit( StaticAssertDecl * assertDecl ) = 0;
    39 
    40         virtual void visit( CompoundStmt * compoundStmt ) = 0;
    41         virtual void visit( ExprStmt * exprStmt ) = 0;
    42         virtual void visit( AsmStmt * asmStmt ) = 0;
    43         virtual void visit( DirectiveStmt * directiveStmt ) = 0;
    44         virtual void visit( IfStmt * ifStmt ) = 0;
    45         virtual void visit( WhileStmt * whileStmt ) = 0;
    46         virtual void visit( ForStmt * forStmt ) = 0;
    47         virtual void visit( SwitchStmt * switchStmt ) = 0;
    48         virtual void visit( CaseStmt * caseStmt ) = 0;
    49         virtual void visit( BranchStmt * branchStmt ) = 0;
    50         virtual void visit( ReturnStmt * returnStmt ) = 0;
    51         virtual void visit( ThrowStmt * throwStmt ) = 0;
    52         virtual void visit( TryStmt * tryStmt ) = 0;
    53         virtual void visit( CatchStmt * catchStmt ) = 0;
    54         virtual void visit( FinallyStmt * finallyStmt ) = 0;
    55         virtual void visit( WaitForStmt * waitforStmt ) = 0;
    56         virtual void visit( WithStmt * withStmt ) = 0;
    57         virtual void visit( NullStmt * nullStmt ) = 0;
    58         virtual void visit( DeclStmt * declStmt ) = 0;
    59         virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
    60 
    61         virtual void visit( ApplicationExpr * applicationExpr ) = 0;
    62         virtual void visit( UntypedExpr * untypedExpr ) = 0;
    63         virtual void visit( NameExpr * nameExpr ) = 0;
    64         virtual void visit( CastExpr * castExpr ) = 0;
    65         virtual void visit( KeywordCastExpr * castExpr ) = 0;
    66         virtual void visit( VirtualCastExpr * castExpr ) = 0;
    67         virtual void visit( AddressExpr * addressExpr ) = 0;
    68         virtual void visit( LabelAddressExpr * labAddressExpr ) = 0;
    69         virtual void visit( UntypedMemberExpr * memberExpr ) = 0;
    70         virtual void visit( MemberExpr * memberExpr ) = 0;
    71         virtual void visit( VariableExpr * variableExpr ) = 0;
    72         virtual void visit( ConstantExpr * constantExpr ) = 0;
    73         virtual void visit( SizeofExpr * sizeofExpr ) = 0;
    74         virtual void visit( AlignofExpr * alignofExpr ) = 0;
    75         virtual void visit( UntypedOffsetofExpr * offsetofExpr ) = 0;
    76         virtual void visit( OffsetofExpr * offsetofExpr ) = 0;
    77         virtual void visit( OffsetPackExpr * offsetPackExpr ) = 0;
    78         virtual void visit( AttrExpr * attrExpr ) = 0;
    79         virtual void visit( LogicalExpr * logicalExpr ) = 0;
    80         virtual void visit( ConditionalExpr * conditionalExpr ) = 0;
    81         virtual void visit( CommaExpr * commaExpr ) = 0;
    82         virtual void visit( TypeExpr * typeExpr ) = 0;
    83         virtual void visit( AsmExpr * asmExpr ) = 0;
    84         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
    85         virtual void visit( ConstructorExpr *  ctorExpr ) = 0;
    86         virtual void visit( CompoundLiteralExpr * compLitExpr ) = 0;
    87         virtual void visit( RangeExpr * rangeExpr ) = 0;
    88         virtual void visit( UntypedTupleExpr * tupleExpr ) = 0;
    89         virtual void visit( TupleExpr * tupleExpr ) = 0;
    90         virtual void visit( TupleIndexExpr * tupleExpr ) = 0;
    91         virtual void visit( TupleAssignExpr * assignExpr ) = 0;
    92         virtual void visit( StmtExpr *  stmtExpr ) = 0;
    93         virtual void visit( UniqueExpr *  uniqueExpr ) = 0;
    94         virtual void visit( UntypedInitExpr *  initExpr ) = 0;
    95         virtual void visit( InitExpr *  initExpr ) = 0;
    96         virtual void visit( DeletedExpr * delExpr ) = 0;
    97         virtual void visit( DefaultArgExpr * argExpr ) = 0;
    98         virtual void visit( GenericExpr * genExpr ) = 0;
    99 
    100         virtual void visit( VoidType * basicType ) = 0;
    101         virtual void visit( BasicType * basicType ) = 0;
    102         virtual void visit( PointerType * pointerType ) = 0;
    103         virtual void visit( ArrayType * arrayType ) = 0;
    104         virtual void visit( ReferenceType * refType ) = 0;
    105         virtual void visit( QualifiedType * qualType ) = 0;
    106         virtual void visit( FunctionType * functionType ) = 0;
    107         virtual void visit( StructInstType * aggregateUseType ) = 0;
    108         virtual void visit( UnionInstType * aggregateUseType ) = 0;
    109         virtual void visit( EnumInstType * aggregateUseType ) = 0;
    110         virtual void visit( TraitInstType * aggregateUseType ) = 0;
    111         virtual void visit( TypeInstType * aggregateUseType ) = 0;
    112         virtual void visit( TupleType * tupleType ) = 0;
    113         virtual void visit( TypeofType * typeofType ) = 0;
    114         virtual void visit( AttrType * attrType ) = 0;
    115         virtual void visit( VarArgsType * varArgsType ) = 0;
    116         virtual void visit( ZeroType * zeroType ) = 0;
    117         virtual void visit( OneType * oneType ) = 0;
    118         virtual void visit( GlobalScopeType * globalType ) = 0;
    119 
    120         virtual void visit( Designation * designation ) = 0;
    121         virtual void visit( SingleInit * singleInit ) = 0;
    122         virtual void visit( ListInit * listInit ) = 0;
    123         virtual void visit( ConstructorInit * ctorInit ) = 0;
    124 
    125         virtual void visit( Constant * constant ) = 0;
    126 
    127         virtual void visit( Attribute * attribute ) = 0;
     29        virtual void visit( ObjectDecl * node ) { visit( const_cast<const ObjectDecl *>(node) ); }
     30        virtual void visit( const ObjectDecl * objectDecl ) = 0;
     31        virtual void visit( FunctionDecl * node ) { visit( const_cast<const FunctionDecl *>(node) ); }
     32        virtual void visit( const FunctionDecl * functionDecl ) = 0;
     33        virtual void visit( StructDecl * node ) { visit( const_cast<const StructDecl *>(node) ); }
     34        virtual void visit( const StructDecl * aggregateDecl ) = 0;
     35        virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
     36        virtual void visit( const UnionDecl * aggregateDecl ) = 0;
     37        virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
     38        virtual void visit( const EnumDecl * aggregateDecl ) = 0;
     39        virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
     40        virtual void visit( const TraitDecl * aggregateDecl ) = 0;
     41        virtual void visit( TypeDecl * node ) { visit( const_cast<const TypeDecl *>(node) ); }
     42        virtual void visit( const TypeDecl * typeDecl ) = 0;
     43        virtual void visit( TypedefDecl * node ) { visit( const_cast<const TypedefDecl *>(node) ); }
     44        virtual void visit( const TypedefDecl * typeDecl ) = 0;
     45        virtual void visit( AsmDecl * node ) { visit( const_cast<const AsmDecl *>(node) ); }
     46        virtual void visit( const AsmDecl * asmDecl ) = 0;
     47        virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
     48        virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
     49
     50        virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }
     51        virtual void visit( const CompoundStmt * compoundStmt ) = 0;
     52        virtual void visit( ExprStmt * node ) { visit( const_cast<const ExprStmt *>(node) ); }
     53        virtual void visit( const ExprStmt * exprStmt ) = 0;
     54        virtual void visit( AsmStmt * node ) { visit( const_cast<const AsmStmt *>(node) ); }
     55        virtual void visit( const AsmStmt * asmStmt ) = 0;
     56        virtual void visit( DirectiveStmt * node ) { visit( const_cast<const DirectiveStmt *>(node) ); }
     57        virtual void visit( const DirectiveStmt * directiveStmt ) = 0;
     58        virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
     59        virtual void visit( const IfStmt * ifStmt ) = 0;
     60        virtual void visit( WhileStmt * node ) { visit( const_cast<const WhileStmt *>(node) ); }
     61        virtual void visit( const WhileStmt * whileStmt ) = 0;
     62        virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
     63        virtual void visit( const ForStmt * forStmt ) = 0;
     64        virtual void visit( SwitchStmt * node ) { visit( const_cast<const SwitchStmt *>(node) ); }
     65        virtual void visit( const SwitchStmt * switchStmt ) = 0;
     66        virtual void visit( CaseStmt * node ) { visit( const_cast<const CaseStmt *>(node) ); }
     67        virtual void visit( const CaseStmt * caseStmt ) = 0;
     68        virtual void visit( BranchStmt * node ) { visit( const_cast<const BranchStmt *>(node) ); }
     69        virtual void visit( const BranchStmt * branchStmt ) = 0;
     70        virtual void visit( ReturnStmt * node ) { visit( const_cast<const ReturnStmt *>(node) ); }
     71        virtual void visit( const ReturnStmt * returnStmt ) = 0;
     72        virtual void visit( ThrowStmt * node ) { visit( const_cast<const ThrowStmt *>(node) ); }
     73        virtual void visit( const ThrowStmt * throwStmt ) = 0;
     74        virtual void visit( TryStmt * node ) { visit( const_cast<const TryStmt *>(node) ); }
     75        virtual void visit( const TryStmt * tryStmt ) = 0;
     76        virtual void visit( CatchStmt * node ) { visit( const_cast<const CatchStmt *>(node) ); }
     77        virtual void visit( const CatchStmt * catchStmt ) = 0;
     78        virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
     79        virtual void visit( const FinallyStmt * finallyStmt ) = 0;
     80        virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
     81        virtual void visit( const WaitForStmt * waitforStmt ) = 0;
     82        virtual void visit( WithStmt * node ) { visit( const_cast<const WithStmt *>(node) ); }
     83        virtual void visit( const WithStmt * withStmt ) = 0;
     84        virtual void visit( NullStmt * node ) { visit( const_cast<const NullStmt *>(node) ); }
     85        virtual void visit( const NullStmt * nullStmt ) = 0;
     86        virtual void visit( DeclStmt * node ) { visit( const_cast<const DeclStmt *>(node) ); }
     87        virtual void visit( const DeclStmt * declStmt ) = 0;
     88        virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
     89        virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
     90
     91        virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }
     92        virtual void visit( const ApplicationExpr * applicationExpr ) = 0;
     93        virtual void visit( UntypedExpr * node ) { visit( const_cast<const UntypedExpr *>(node) ); }
     94        virtual void visit( const UntypedExpr * untypedExpr ) = 0;
     95        virtual void visit( NameExpr * node ) { visit( const_cast<const NameExpr *>(node) ); }
     96        virtual void visit( const NameExpr * nameExpr ) = 0;
     97        virtual void visit( CastExpr * node ) { visit( const_cast<const CastExpr *>(node) ); }
     98        virtual void visit( const CastExpr * castExpr ) = 0;
     99        virtual void visit( KeywordCastExpr * node ) { visit( const_cast<const KeywordCastExpr *>(node) ); }
     100        virtual void visit( const KeywordCastExpr * castExpr ) = 0;
     101        virtual void visit( VirtualCastExpr * node ) { visit( const_cast<const VirtualCastExpr *>(node) ); }
     102        virtual void visit( const VirtualCastExpr * castExpr ) = 0;
     103        virtual void visit( AddressExpr * node ) { visit( const_cast<const AddressExpr *>(node) ); }
     104        virtual void visit( const AddressExpr * addressExpr ) = 0;
     105        virtual void visit( LabelAddressExpr * node ) { visit( const_cast<const LabelAddressExpr *>(node) ); }
     106        virtual void visit( const LabelAddressExpr * labAddressExpr ) = 0;
     107        virtual void visit( UntypedMemberExpr * node ) { visit( const_cast<const UntypedMemberExpr *>(node) ); }
     108        virtual void visit( const UntypedMemberExpr * memberExpr ) = 0;
     109        virtual void visit( MemberExpr * node ) { visit( const_cast<const MemberExpr *>(node) ); }
     110        virtual void visit( const MemberExpr * memberExpr ) = 0;
     111        virtual void visit( VariableExpr * node ) { visit( const_cast<const VariableExpr *>(node) ); }
     112        virtual void visit( const VariableExpr * variableExpr ) = 0;
     113        virtual void visit( ConstantExpr * node ) { visit( const_cast<const ConstantExpr *>(node) ); }
     114        virtual void visit( const ConstantExpr * constantExpr ) = 0;
     115        virtual void visit( SizeofExpr * node ) { visit( const_cast<const SizeofExpr *>(node) ); }
     116        virtual void visit( const SizeofExpr * sizeofExpr ) = 0;
     117        virtual void visit( AlignofExpr * node ) { visit( const_cast<const AlignofExpr *>(node) ); }
     118        virtual void visit( const AlignofExpr * alignofExpr ) = 0;
     119        virtual void visit( UntypedOffsetofExpr * node ) { visit( const_cast<const UntypedOffsetofExpr *>(node) ); }
     120        virtual void visit( const UntypedOffsetofExpr * offsetofExpr ) = 0;
     121        virtual void visit( OffsetofExpr * node ) { visit( const_cast<const OffsetofExpr *>(node) ); }
     122        virtual void visit( const OffsetofExpr * offsetofExpr ) = 0;
     123        virtual void visit( OffsetPackExpr * node ) { visit( const_cast<const OffsetPackExpr *>(node) ); }
     124        virtual void visit( const OffsetPackExpr * offsetPackExpr ) = 0;
     125        virtual void visit( AttrExpr * node ) { visit( const_cast<const AttrExpr *>(node) ); }
     126        virtual void visit( const AttrExpr * attrExpr ) = 0;
     127        virtual void visit( LogicalExpr * node ) { visit( const_cast<const LogicalExpr *>(node) ); }
     128        virtual void visit( const LogicalExpr * logicalExpr ) = 0;
     129        virtual void visit( ConditionalExpr * node ) { visit( const_cast<const ConditionalExpr *>(node) ); }
     130        virtual void visit( const ConditionalExpr * conditionalExpr ) = 0;
     131        virtual void visit( CommaExpr * node ) { visit( const_cast<const CommaExpr *>(node) ); }
     132        virtual void visit( const CommaExpr * commaExpr ) = 0;
     133        virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
     134        virtual void visit( const TypeExpr * typeExpr ) = 0;
     135        virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
     136        virtual void visit( const AsmExpr * asmExpr ) = 0;
     137        virtual void visit( ImplicitCopyCtorExpr * node ) { visit( const_cast<const ImplicitCopyCtorExpr *>(node) ); }
     138        virtual void visit( const ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
     139        virtual void visit( ConstructorExpr * node ) { visit( const_cast<const ConstructorExpr *>(node) ); }
     140        virtual void visit( const ConstructorExpr *  ctorExpr ) = 0;
     141        virtual void visit( CompoundLiteralExpr * node ) { visit( const_cast<const CompoundLiteralExpr *>(node) ); }
     142        virtual void visit( const CompoundLiteralExpr * compLitExpr ) = 0;
     143        virtual void visit( RangeExpr * node ) { visit( const_cast<const RangeExpr *>(node) ); }
     144        virtual void visit( const RangeExpr * rangeExpr ) = 0;
     145        virtual void visit( UntypedTupleExpr * node ) { visit( const_cast<const UntypedTupleExpr *>(node) ); }
     146        virtual void visit( const UntypedTupleExpr * tupleExpr ) = 0;
     147        virtual void visit( TupleExpr * node ) { visit( const_cast<const TupleExpr *>(node) ); }
     148        virtual void visit( const TupleExpr * tupleExpr ) = 0;
     149        virtual void visit( TupleIndexExpr * node ) { visit( const_cast<const TupleIndexExpr *>(node) ); }
     150        virtual void visit( const TupleIndexExpr * tupleExpr ) = 0;
     151        virtual void visit( TupleAssignExpr * node ) { visit( const_cast<const TupleAssignExpr *>(node) ); }
     152        virtual void visit( const TupleAssignExpr * assignExpr ) = 0;
     153        virtual void visit( StmtExpr * node ) { visit( const_cast<const StmtExpr *>(node) ); }
     154        virtual void visit( const StmtExpr *  stmtExpr ) = 0;
     155        virtual void visit( UniqueExpr * node ) { visit( const_cast<const UniqueExpr *>(node) ); }
     156        virtual void visit( const UniqueExpr *  uniqueExpr ) = 0;
     157        virtual void visit( UntypedInitExpr * node ) { visit( const_cast<const UntypedInitExpr *>(node) ); }
     158        virtual void visit( const UntypedInitExpr *  initExpr ) = 0;
     159        virtual void visit( InitExpr * node ) { visit( const_cast<const InitExpr *>(node) ); }
     160        virtual void visit( const InitExpr *  initExpr ) = 0;
     161        virtual void visit( DeletedExpr * node ) { visit( const_cast<const DeletedExpr *>(node) ); }
     162        virtual void visit( const DeletedExpr * delExpr ) = 0;
     163        virtual void visit( DefaultArgExpr * node ) { visit( const_cast<const DefaultArgExpr *>(node) ); }
     164        virtual void visit( const DefaultArgExpr * argExpr ) = 0;
     165        virtual void visit( GenericExpr * node ) { visit( const_cast<const GenericExpr *>(node) ); }
     166        virtual void visit( const GenericExpr * genExpr ) = 0;
     167
     168        virtual void visit( VoidType * node ) { visit( const_cast<const VoidType *>(node) ); }
     169        virtual void visit( const VoidType * basicType ) = 0;
     170        virtual void visit( BasicType * node ) { visit( const_cast<const BasicType *>(node) ); }
     171        virtual void visit( const BasicType * basicType ) = 0;
     172        virtual void visit( PointerType * node ) { visit( const_cast<const PointerType *>(node) ); }
     173        virtual void visit( const PointerType * pointerType ) = 0;
     174        virtual void visit( ArrayType * node ) { visit( const_cast<const ArrayType *>(node) ); }
     175        virtual void visit( const ArrayType * arrayType ) = 0;
     176        virtual void visit( ReferenceType * node ) { visit( const_cast<const ReferenceType *>(node) ); }
     177        virtual void visit( const ReferenceType * refType ) = 0;
     178        virtual void visit( QualifiedType * node ) { visit( const_cast<const QualifiedType *>(node) ); }
     179        virtual void visit( const QualifiedType * qualType ) = 0;
     180        virtual void visit( FunctionType * node ) { visit( const_cast<const FunctionType *>(node) ); }
     181        virtual void visit( const FunctionType * functionType ) = 0;
     182        virtual void visit( StructInstType * node ) { visit( const_cast<const StructInstType *>(node) ); }
     183        virtual void visit( const StructInstType * aggregateUseType ) = 0;
     184        virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
     185        virtual void visit( const UnionInstType * aggregateUseType ) = 0;
     186        virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
     187        virtual void visit( const EnumInstType * aggregateUseType ) = 0;
     188        virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }
     189        virtual void visit( const TraitInstType * aggregateUseType ) = 0;
     190        virtual void visit( TypeInstType * node ) { visit( const_cast<const TypeInstType *>(node) ); }
     191        virtual void visit( const TypeInstType * aggregateUseType ) = 0;
     192        virtual void visit( TupleType * node ) { visit( const_cast<const TupleType *>(node) ); }
     193        virtual void visit( const TupleType * tupleType ) = 0;
     194        virtual void visit( TypeofType * node ) { visit( const_cast<const TypeofType *>(node) ); }
     195        virtual void visit( const TypeofType * typeofType ) = 0;
     196        virtual void visit( AttrType * node ) { visit( const_cast<const AttrType *>(node) ); }
     197        virtual void visit( const AttrType * attrType ) = 0;
     198        virtual void visit( VarArgsType * node ) { visit( const_cast<const VarArgsType *>(node) ); }
     199        virtual void visit( const VarArgsType * varArgsType ) = 0;
     200        virtual void visit( ZeroType * node ) { visit( const_cast<const ZeroType *>(node) ); }
     201        virtual void visit( const ZeroType * zeroType ) = 0;
     202        virtual void visit( OneType * node ) { visit( const_cast<const OneType *>(node) ); }
     203        virtual void visit( const OneType * oneType ) = 0;
     204        virtual void visit( GlobalScopeType * node ) { visit( const_cast<const GlobalScopeType *>(node) ); }
     205        virtual void visit( const GlobalScopeType * globalType ) = 0;
     206
     207        virtual void visit( Designation * node ) { visit( const_cast<const Designation *>(node) ); }
     208        virtual void visit( const Designation * designation ) = 0;
     209        virtual void visit( SingleInit * node ) { visit( const_cast<const SingleInit *>(node) ); }
     210        virtual void visit( const SingleInit * singleInit ) = 0;
     211        virtual void visit( ListInit * node ) { visit( const_cast<const ListInit *>(node) ); }
     212        virtual void visit( const ListInit * listInit ) = 0;
     213        virtual void visit( ConstructorInit * node ) { visit( const_cast<const ConstructorInit *>(node) ); }
     214        virtual void visit( const ConstructorInit * ctorInit ) = 0;
     215
     216        virtual void visit( Constant * node ) { visit( const_cast<const Constant *>(node) ); }
     217        virtual void visit( const Constant * constant ) = 0;
     218
     219        virtual void visit( Attribute * node ) { visit( const_cast<const Attribute *>(node) ); }
     220        virtual void visit( const Attribute * attribute ) = 0;
    128221};
    129222
Note: See TracChangeset for help on using the changeset viewer.