Changeset 6d51bd7


Ignore:
Timestamp:
May 15, 2019, 10:15:44 AM (3 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
be567e9
Parents:
712348a
Message:

Fixes to the new templated pass and started on conversions

Location:
src/AST
Files:
2 added
14 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Attribute.hpp

    r712348a r6d51bd7  
    1919#include <vector>
    2020
     21#include "Fwd.hpp"
    2122#include "Node.hpp"     // for ptr
    2223#include "Visitor.hpp"
     
    3132        std::vector<ptr<Expr>> parameters;
    3233
    33         Attribute( const std::string& name = "", std::vector<ptr<Expr>>&& params = {})
     34        Attribute( const std::string & name = "", std::vector<ptr<Expr>> && params = {})
    3435        : name( name ), parameters( params ) {}
     36        virtual ~Attribute() = default;
    3537
    3638        bool empty() const { return name.empty(); }
     
    4244        bool isValidOnFuncParam() const;
    4345
    44         Attribute* accept( Visitor& v ) override { return v.visit( this ); }
     46        const Attribute * accept( Visitor & v ) const override { return v.visit( this ); }
    4547private:
    46         Attribute* clone() const override { return new Attribute{ *this }; }
     48        Attribute * clone() const override { return new Attribute{ *this }; }
     49
     50        /// Must be copied in ALL derived classes
     51        template<typename node_t>
     52        friend auto mutate(const node_t * node);
    4753};
    4854
  • src/AST/Decl.hpp

    r712348a r6d51bd7  
    5757        static readonly<Decl> fromId( UniqueId id );
    5858
    59         virtual Decl* accept( Visitor& v ) override = 0;
    60 private:
    61         virtual Decl* clone() const override = 0;
     59        virtual const Decl * accept( Visitor & v ) const override = 0;
     60private:
     61        virtual Decl * clone() const override = 0;
    6262};
    6363
     
    8585
    8686        /// Get type of this declaration. May be generated by subclass
    87         virtual const Type* get_type() const = 0;
     87        virtual const Type * get_type() const = 0;
    8888        /// Set type of this declaration. May be verified by subclass
    8989        virtual void set_type(Type*) = 0;
    9090
    91         virtual DeclWithType* accept( Visitor& v ) override = 0;
    92 private:
    93         virtual DeclWithType* clone() const override = 0;
     91        virtual const DeclWithType * accept( Visitor & v ) const override = 0;
     92private:
     93        virtual DeclWithType * clone() const override = 0;
    9494};
    9595
     
    110110        void set_type( Type* ty ) override { type = ty; }
    111111
    112         DeclWithType* accept( Visitor& v ) override { return v.visit( this ); }
    113 private:
    114         ObjectDecl* clone() const override { return new ObjectDecl{ *this }; }
     112        virtual const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
     113private:
     114        virtual ObjectDecl * clone() const override { return new ObjectDecl{ *this }; }
     115
     116        /// Must be copied in ALL derived classes
     117        template<typename node_t>
     118        friend auto mutate(const node_t * node);
    115119};
    116120
     
    166170        std::string genTypeString() const;
    167171
    168         Decl* accept( Visitor& v ) override { return v.visit( this ); }
    169 private:
    170         TypeDecl* clone() const override { return new TypeDecl{ *this }; }
     172        virtual const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
     173private:
     174        virtual TypeDecl * clone() const override { return new TypeDecl{ *this }; }
    171175};
    172176
     
    180184        std::string typeString() const override { return "typedef"; }
    181185
    182         Decl* accept( Visitor& v ) override { return v.visit( this ); }
    183 private:
    184         TypedefDecl* clone() const override { return new TypedefDecl{ *this }; }
     186        virtual const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
     187private:
     188        virtual TypedefDecl * clone() const override { return new TypedefDecl{ *this }; }
    185189};
    186190
     
    220224        bool is_thread() { return kind == DeclarationNode::Thread; }
    221225
    222         Decl* accept( Visitor& v ) override { return v.visit( this ); }
    223 private:
    224         StructDecl* clone() const override { return new StructDecl{ *this }; }
     226        virtual const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
     227private:
     228        virtual StructDecl * clone() const override { return new StructDecl{ *this }; }
    225229
    226230        std::string typeString() const override { return "struct"; }
     
    234238        : AggregateDecl( loc, name, std::move(attrs), linkage ) {}
    235239
    236         Decl* accept( Visitor& v ) override { return v.visit( this ); }
    237 private:
    238         UnionDecl* clone() const override { return new UnionDecl{ *this }; }
     240        virtual const Decl * accept( Visitor& v ) const override { return v.visit( this ); }
     241private:
     242        virtual UnionDecl * clone() const override { return new UnionDecl{ *this }; }
    239243
    240244        std::string typeString() const override { return "union"; }
     
    251255        bool valueOf( Decl* enumerator, long long& value ) const;
    252256
    253         Decl* accept( Visitor& v ) override { return v.visit( this ); }
    254 private:
    255         EnumDecl* clone() const override { return new EnumDecl{ *this }; }
     257        virtual const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
     258private:
     259        virtual EnumDecl * clone() const override { return new EnumDecl{ *this }; }
    256260
    257261        std::string typeString() const override { return "enum"; }
     
    268272        : AggregateDecl( loc, name, std::move(attrs), linkage ) {}
    269273
    270         Decl* accept( Visitor& v ) override { return v.visit( this ); }
    271 private:
    272         TraitDecl* clone() const override { return new TraitDecl{ *this }; }
     274        virtual const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
     275private:
     276        virtual TraitDecl * clone() const override { return new TraitDecl{ *this }; }
    273277
    274278        std::string typeString() const override { return "trait"; }
     
    287291inline void increment( const class ObjectDecl * node, Node::ref_type ref ) { node->increment(ref); }
    288292inline void decrement( const class ObjectDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    289 inline void increment( const class FunctionDecl * node, Node::ref_type ref ) { node->increment(ref); }
    290 inline void decrement( const class FunctionDecl * node, Node::ref_type ref ) { node->decrement(ref); }
     293// inline void increment( const class FunctionDecl * node, Node::ref_type ref ) { node->increment(ref); }
     294// inline void decrement( const class FunctionDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    291295inline void increment( const class AggregateDecl * node, Node::ref_type ref ) { node->increment(ref); }
    292296inline void decrement( const class AggregateDecl * node, Node::ref_type ref ) { node->decrement(ref); }
     
    303307inline void increment( const class TypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
    304308inline void decrement( const class TypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    305 inline void increment( const class FtypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
    306 inline void decrement( const class FtypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    307 inline void increment( const class DtypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
    308 inline void decrement( const class DtypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
     309// inline void increment( const class FtypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
     310// inline void decrement( const class FtypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
     311// inline void increment( const class DtypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
     312// inline void decrement( const class DtypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    309313inline void increment( const class TypedefDecl * node, Node::ref_type ref ) { node->increment(ref); }
    310314inline void decrement( const class TypedefDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    311 inline void increment( const class AsmDecl * node, Node::ref_type ref ) { node->increment(ref); }
    312 inline void decrement( const class AsmDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    313 inline void increment( const class StaticAssertDecl * node, Node::ref_type ref ) { node->increment(ref); }
    314 inline void decrement( const class StaticAssertDecl * node, Node::ref_type ref ) { node->decrement(ref); }
     315// inline void increment( const class AsmDecl * node, Node::ref_type ref ) { node->increment(ref); }
     316// inline void decrement( const class AsmDecl * node, Node::ref_type ref ) { node->decrement(ref); }
     317// inline void increment( const class StaticAssertDecl * node, Node::ref_type ref ) { node->increment(ref); }
     318// inline void decrement( const class StaticAssertDecl * node, Node::ref_type ref ) { node->decrement(ref); }
    315319
    316320}
  • src/AST/Expr.hpp

    r712348a r6d51bd7  
    2727namespace ast {
    2828
    29 /// Contains the ID of a declaration and a type that is derived from that declaration, 
     29/// Contains the ID of a declaration and a type that is derived from that declaration,
    3030/// but subject to decay-to-pointer and type parameter renaming
    3131struct ParamEntry {
     
    7474                        case Empty:  return;
    7575                        case Slots:  new(&data.resnSlots) ResnSlots{ std::move(o.data.resnSlots) }; return;
    76                         case Params: 
     76                        case Params:
    7777                                new(&data.inferParams) InferredParams{ std::move(o.data.inferParams) }; return;
    7878                        }
     
    121121        Expr* set_extension( bool ex ) { extension = ex; return this; }
    122122
    123         virtual Expr* accept( Visitor& v ) override = 0;
     123        virtual const Expr * accept( Visitor& v ) const override = 0;
    124124private:
    125         virtual Expr* clone() const override = 0;
     125        virtual Expr * clone() const override = 0;
    126126};
    127127
     128
     129//=================================================================================================
     130/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
     131/// remove only if there is a better solution
     132/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
     133/// forward declarations
     134inline void increment( const class Expr * node, Node::ref_type ref ) { node->increment(ref); }
     135inline void decrement( const class Expr * node, Node::ref_type ref ) { node->decrement(ref); }
     136// inline void increment( const class ApplicationExpr * node, Node::ref_type ref ) { node->increment(ref); }
     137// inline void decrement( const class ApplicationExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     138// inline void increment( const class UntypedExpr * node, Node::ref_type ref ) { node->increment(ref); }
     139// inline void decrement( const class UntypedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     140// inline void increment( const class NameExpr * node, Node::ref_type ref ) { node->increment(ref); }
     141// inline void decrement( const class NameExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     142// inline void increment( const class AddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
     143// inline void decrement( const class AddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     144// inline void increment( const class LabelAddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
     145// inline void decrement( const class LabelAddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     146// inline void increment( const class CastExpr * node, Node::ref_type ref ) { node->increment(ref); }
     147// inline void decrement( const class CastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     148// inline void increment( const class KeywordCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
     149// inline void decrement( const class KeywordCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     150// inline void increment( const class VirtualCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
     151// inline void decrement( const class VirtualCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     152// inline void increment( const class MemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
     153// inline void decrement( const class MemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     154// inline void increment( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
     155// inline void decrement( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     156// inline void increment( const class VariableExpr * node, Node::ref_type ref ) { node->increment(ref); }
     157// inline void decrement( const class VariableExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     158// inline void increment( const class ConstantExpr * node, Node::ref_type ref ) { node->increment(ref); }
     159// inline void decrement( const class ConstantExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     160// inline void increment( const class SizeofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     161// inline void decrement( const class SizeofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     162// inline void increment( const class AlignofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     163// inline void decrement( const class AlignofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     164// inline void increment( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     165// inline void decrement( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     166// inline void increment( const class OffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     167// inline void decrement( const class OffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     168// inline void increment( const class OffsetPackExpr * node, Node::ref_type ref ) { node->increment(ref); }
     169// inline void decrement( const class OffsetPackExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     170// inline void increment( const class AttrExpr * node, Node::ref_type ref ) { node->increment(ref); }
     171// inline void decrement( const class AttrExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     172// inline void increment( const class LogicalExpr * node, Node::ref_type ref ) { node->increment(ref); }
     173// inline void decrement( const class LogicalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     174// inline void increment( const class ConditionalExpr * node, Node::ref_type ref ) { node->increment(ref); }
     175// inline void decrement( const class ConditionalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     176// inline void increment( const class CommaExpr * node, Node::ref_type ref ) { node->increment(ref); }
     177// inline void decrement( const class CommaExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     178// inline void increment( const class TypeExpr * node, Node::ref_type ref ) { node->increment(ref); }
     179// inline void decrement( const class TypeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     180// inline void increment( const class AsmExpr * node, Node::ref_type ref ) { node->increment(ref); }
     181// inline void decrement( const class AsmExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     182// inline void increment( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->increment(ref); }
     183// inline void decrement( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     184// inline void increment( const class ConstructorExpr * node, Node::ref_type ref ) { node->increment(ref); }
     185// inline void decrement( const class ConstructorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     186// inline void increment( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->increment(ref); }
     187// inline void decrement( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     188// inline void increment( const class UntypedValofExpr * node, Node::ref_type ref ) { node->increment(ref); }
     189// inline void decrement( const class UntypedValofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     190// inline void increment( const class RangeExpr * node, Node::ref_type ref ) { node->increment(ref); }
     191// inline void decrement( const class RangeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     192// inline void increment( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
     193// inline void decrement( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     194// inline void increment( const class TupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
     195// inline void decrement( const class TupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     196// inline void increment( const class TupleIndexExpr * node, Node::ref_type ref ) { node->increment(ref); }
     197// inline void decrement( const class TupleIndexExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     198// inline void increment( const class TupleAssignExpr * node, Node::ref_type ref ) { node->increment(ref); }
     199// inline void decrement( const class TupleAssignExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     200// inline void increment( const class StmtExpr * node, Node::ref_type ref ) { node->increment(ref); }
     201// inline void decrement( const class StmtExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     202// inline void increment( const class UniqueExpr * node, Node::ref_type ref ) { node->increment(ref); }
     203// inline void decrement( const class UniqueExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     204// inline void increment( const class UntypedInitExpr * node, Node::ref_type ref ) { node->increment(ref); }
     205// inline void decrement( const class UntypedInitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     206// inline void increment( const class InitExpr * node, Node::ref_type ref ) { node->increment(ref); }
     207// inline void decrement( const class InitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     208// inline void increment( const class DeletedExpr * node, Node::ref_type ref ) { node->increment(ref); }
     209// inline void decrement( const class DeletedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     210// inline void increment( const class DefaultArgExpr * node, Node::ref_type ref ) { node->increment(ref); }
     211// inline void decrement( const class DefaultArgExpr * node, Node::ref_type ref ) { node->decrement(ref); }
     212// inline void increment( const class GenericExpr * node, Node::ref_type ref ) { node->increment(ref); }
     213// inline void decrement( const class GenericExpr * node, Node::ref_type ref ) { node->decrement(ref); }
    128214}
    129215
  • src/AST/Fwd.hpp

    r712348a r6d51bd7  
    137137
    138138class TypeSubstitution;
     139
     140std::string toString( const Node * );
    139141
    140142//=================================================================================================
     
    355357inline void increment( const class Constant *, Node::ref_type );
    356358inline void decrement( const class Constant *, Node::ref_type );
    357 inline void increment( const class Label *, Node::ref_type );
    358 inline void decrement( const class Label *, Node::ref_type );
    359359inline void increment( const class Attribute *, Node::ref_type );
    360360inline void decrement( const class Attribute *, Node::ref_type );
  • src/AST/Init.hpp

    r712348a r6d51bd7  
    3737        : ParseNode( loc ), designators( std::move(ds) ) {}
    3838
    39         Designation* accept( Visitor& v ) override { return v.visit( this ); }
     39        virtual const Designation* accept( Visitor& v ) const override { return v.visit( this ); }
    4040private:
    41         Designation* clone() const override { return new Designation{ *this }; }
     41        virtual Designation* clone() const override { return new Designation{ *this }; }
    4242};
    4343
     
    4949        Init( const CodeLocation& loc, bool mc ) : ParseNode( loc ), maybeConstructed( mc ) {}
    5050
    51         virtual Init* accept( Visitor& v ) override = 0;
     51        virtual const Init * accept( Visitor& v ) const override = 0;
    5252private:
    53         virtual Init* clone() const override = 0;
     53        virtual const Init * clone() const override = 0;
    5454};
    5555
     
    6363        : Init( loc, mc ), value( val ) {}
    6464
    65         Init* accept( Visitor& v ) override { return v.visit( this ); }
     65        virtual const Init * accept( Visitor & v ) const override { return v.visit( this ); }
    6666private:
    67         SingleInit* clone() const override { return new SingleInit{ *this }; }
     67        virtual SingleInit * clone() const override { return new SingleInit{ *this }; }
     68
     69        /// Must be copied in ALL derived classes
     70        template<typename node_t>
     71        friend auto mutate(const node_t * node);
    6872};
    6973
     
    8791        const_iterator end() const { return initializers.end(); }
    8892
    89         Init* accept( Visitor& v ) override { return v.visit( this ); }
     93        virtual const Init * accept( Visitor & v ) const override { return v.visit( this ); }
    9094private:
    91         ListInit* clone() const override { return new ListInit{ *this }; }
     95        virtual ListInit * clone() const override { return new ListInit{ *this }; }
     96
     97        /// Must be copied in ALL derived classes
     98        template<typename node_t>
     99        friend auto mutate(const node_t * node);
    92100};
    93101
     
    106114        : Init( loc, true ), ctor( ctor ), dtor( dtor ), init( init ) {}
    107115
    108         Init* accept( Visitor& v ) override { return v.visit( this ); }
     116        virtual const Init * accept( Visitor & v ) const override { return v.visit( this ); }
    109117private:
    110         ConstructorInit* clone() const override { return new ConstructorInit{ *this }; }
     118        virtual ConstructorInit * clone() const override { return new ConstructorInit{ *this }; }
     119
     120        /// Must be copied in ALL derived classes
     121        template<typename node_t>
     122        friend auto mutate(const node_t * node);
    111123};
    112124
  • src/AST/Label.hpp

    r712348a r6d51bd7  
    3535
    3636        Label( CodeLocation loc, const std::string& name = "",
    37                 const std::vector<ptr<Attribute>>& attrs = std::vector<ptr<Attribute>>{} )
     37                std::vector<ptr<Attribute>> && attrs = std::vector<ptr<Attribute>>{} )
    3838        : location( loc ), name( name ), attributes( attrs ) {}
    3939
     
    4848inline std::ostream& operator<< ( std::ostream& out, const Label& l ) { return out << l.name; }
    4949
    50 
    51 //=================================================================================================
    52 /// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
    53 /// remove only if there is a better solution
    54 /// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
    55 /// forward declarations
    56 inline void increment( const class Label * node, Node::ref_type ref ) { node->increment( ref ); }
    57 inline void decrement( const class Label * node, Node::ref_type ref ) { node->decrement( ref ); }
    58 
    5950}
    6051
  • src/AST/Node.hpp

    r712348a r6d51bd7  
    3030        // change/share reference counts
    3131        Node() = default;
    32         Node(const Node&) : strong_ref(0), weak_ref(0) {}
    33         Node(Node&&) : strong_ref(0), weak_ref(0) {}
     32        Node(const Node&) : strong_count(0), weak_count(0) {}
     33        Node(Node&&) : strong_count(0), weak_count(0) {}
    3434        Node& operator= (const Node&) = delete;
    3535        Node& operator= (Node&&) = delete;
    3636        virtual ~Node() = default;
    3737
    38         virtual Node* accept( Visitor& v ) = 0;
     38        virtual const Node * accept( Visitor & v ) const = 0;
    3939
    4040        /// Types of node references
     
    4646        inline void increment(ref_type ref) const {
    4747                switch (ref) {
    48                         case ref_type::strong: strong_ref++; break;
    49                         case ref_type::weak  : weak_ref  ++; break;
     48                        case ref_type::strong: strong_count++; break;
     49                        case ref_type::weak  : weak_count  ++; break;
    5050                }
    5151        }
     
    5353        inline void decrement(ref_type ref) const {
    5454                switch (ref) {
    55                         case ref_type::strong: strong_ref--; break;
    56                         case ref_type::weak  : weak_ref  --; break;
     55                        case ref_type::strong: strong_count--; break;
     56                        case ref_type::weak  : weak_count  --; break;
    5757                }
    5858
    59                 if(!strong_ref && !weak_ref) {
     59                if(!strong_count && !weak_count) {
    6060                        delete this;
    6161                }
    6262        }
     63private:
     64        /// Make a copy of this node; should be overridden in subclass with more precise return type
     65        virtual const Node * clone() const = 0;
    6366
     67        /// Must be copied in ALL derived classes
    6468        template<typename node_t>
    6569        friend auto mutate(const node_t * node);
    6670
    67 private:
    68         /// Make a copy of this node; should be overridden in subclass with more precise return type
    69         virtual Node* clone() const = 0;
    70 
    71         mutable size_t strong_ref = 0;
    72         mutable size_t weak_ref = 0;
     71        mutable size_t strong_count = 0;
     72        mutable size_t weak_count = 0;
    7373};
    7474
     
    100100public:
    101101        ptr_base() : node(nullptr) {}
    102         ptr_base( node_t * n ) : node(n) { if( !node ) node->increment(ref_t); }
    103         ~ptr_base() { if( node ) node->decrement(ref_t); }
     102        ptr_base( const node_t * n ) : node(n) { if( !node ) increment(node, ref_t); }
     103        ~ptr_base() { if( node ) decrement(node, ref_t); }
    104104
    105105        template< enum  Node::ref_type o_ref_t >
    106106        ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.node) {
    107107                if( !node ) return;
    108                 node->increment(ref_t);
     108                increment(node, ref_t);
    109109        }
    110110
    111111        template< enum  Node::ref_type o_ref_t >
    112112        ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.node) {
    113                 if( node ) node->increment(ref_t);
     113                if( node ) increment(node, ref_t);
     114        }
     115
     116        template<typename o_node_t>
     117        ptr_base & operator=( const o_node_t * node ) {
     118                assign(strict_dynamic_cast<const node_t *>(node));
     119                return *this;
    114120        }
    115121
     
    136142
    137143private:
    138         void assign(node_t * other ) {
    139                 if( other ) other->increment(ref_t);
    140                 if( node  ) node ->decrement(ref_t);
     144        void assign(const node_t * other ) {
     145                if( other ) increment(other, ref_t);
     146                if( node  ) decrement(node , ref_t);
    141147                node = other;
    142148        }
    143149
    144150protected:
    145         node_t * node;
     151        const node_t * node;
    146152};
    147153
  • src/AST/Pass.hpp

    r712348a r6d51bd7  
    2323#include "AST/Fwd.hpp"
    2424#include "AST/Node.hpp"
     25
     26#include "AST/Attribute.hpp"
    2527#include "AST/Decl.hpp"
     28#include "AST/Expr.hpp"
     29#include "AST/Init.hpp"
     30#include "AST/Stmt.hpp"
     31
    2632#include "AST/Visitor.hpp"
    2733
     
    7985
    8086        /// Visit function declarations
    81         virtual DeclWithType *     visit( const ObjectDecl           * ) override final;
    82         virtual DeclWithType *     visit( const FunctionDecl         * ) override final;
    83         virtual Decl *             visit( const StructDecl           * ) override final;
    84         virtual Decl *             visit( const UnionDecl            * ) override final;
    85         virtual Decl *             visit( const EnumDecl             * ) override final;
    86         virtual Decl *             visit( const TraitDecl            * ) override final;
    87         virtual Decl *             visit( const TypeDecl             * ) override final;
    88         virtual Decl *             visit( const TypedefDecl          * ) override final;
    89         virtual AsmDecl *          visit( const AsmDecl              * ) override final;
    90         virtual StaticAssertDecl * visit( const StaticAssertDecl     * ) override final;
    91         virtual CompoundStmt *     visit( const CompoundStmt         * ) override final;
    92         virtual Stmt *             visit( const ExprStmt             * ) override final;
    93         virtual Stmt *             visit( const AsmStmt              * ) override final;
    94         virtual Stmt *             visit( const DirectiveStmt        * ) override final;
    95         virtual Stmt *             visit( const IfStmt               * ) override final;
    96         virtual Stmt *             visit( const WhileStmt            * ) override final;
    97         virtual Stmt *             visit( const ForStmt              * ) override final;
    98         virtual Stmt *             visit( const SwitchStmt           * ) override final;
    99         virtual Stmt *             visit( const CaseStmt             * ) override final;
    100         virtual Stmt *             visit( const BranchStmt           * ) override final;
    101         virtual Stmt *             visit( const ReturnStmt           * ) override final;
    102         virtual Stmt *             visit( const ThrowStmt            * ) override final;
    103         virtual Stmt *             visit( const TryStmt              * ) override final;
    104         virtual Stmt *             visit( const CatchStmt            * ) override final;
    105         virtual Stmt *             visit( const FinallyStmt          * ) override final;
    106         virtual Stmt *             visit( const WaitForStmt          * ) override final;
    107         virtual Stmt *             visit( const WithStmt             * ) override final;
    108         virtual NullStmt *         visit( const NullStmt             * ) override final;
    109         virtual Stmt *             visit( const DeclStmt             * ) override final;
    110         virtual Stmt *             visit( const ImplicitCtorDtorStmt * ) override final;
    111         virtual Expr *             visit( const ApplicationExpr      * ) override final;
    112         virtual Expr *             visit( const UntypedExpr          * ) override final;
    113         virtual Expr *             visit( const NameExpr             * ) override final;
    114         virtual Expr *             visit( const AddressExpr          * ) override final;
    115         virtual Expr *             visit( const LabelAddressExpr     * ) override final;
    116         virtual Expr *             visit( const CastExpr             * ) override final;
    117         virtual Expr *             visit( const KeywordCastExpr      * ) override final;
    118         virtual Expr *             visit( const VirtualCastExpr      * ) override final;
    119         virtual Expr *             visit( const UntypedMemberExpr    * ) override final;
    120         virtual Expr *             visit( const MemberExpr           * ) override final;
    121         virtual Expr *             visit( const VariableExpr         * ) override final;
    122         virtual Expr *             visit( const ConstantExpr         * ) override final;
    123         virtual Expr *             visit( const SizeofExpr           * ) override final;
    124         virtual Expr *             visit( const AlignofExpr          * ) override final;
    125         virtual Expr *             visit( const UntypedOffsetofExpr  * ) override final;
    126         virtual Expr *             visit( const OffsetofExpr         * ) override final;
    127         virtual Expr *             visit( const OffsetPackExpr       * ) override final;
    128         virtual Expr *             visit( const AttrExpr             * ) override final;
    129         virtual Expr *             visit( const LogicalExpr          * ) override final;
    130         virtual Expr *             visit( const ConditionalExpr      * ) override final;
    131         virtual Expr *             visit( const CommaExpr            * ) override final;
    132         virtual Expr *             visit( const TypeExpr             * ) override final;
    133         virtual Expr *             visit( const AsmExpr              * ) override final;
    134         virtual Expr *             visit( const ImplicitCopyCtorExpr * ) override final;
    135         virtual Expr *             visit( const ConstructorExpr      * ) override final;
    136         virtual Expr *             visit( const CompoundLiteralExpr  * ) override final;
    137         virtual Expr *             visit( const RangeExpr            * ) override final;
    138         virtual Expr *             visit( const UntypedTupleExpr     * ) override final;
    139         virtual Expr *             visit( const TupleExpr            * ) override final;
    140         virtual Expr *             visit( const TupleIndexExpr       * ) override final;
    141         virtual Expr *             visit( const TupleAssignExpr      * ) override final;
    142         virtual Expr *             visit( const StmtExpr             * ) override final;
    143         virtual Expr *             visit( const UniqueExpr           * ) override final;
    144         virtual Expr *             visit( const UntypedInitExpr      * ) override final;
    145         virtual Expr *             visit( const InitExpr             * ) override final;
    146         virtual Expr *             visit( const DeletedExpr          * ) override final;
    147         virtual Expr *             visit( const DefaultArgExpr       * ) override final;
    148         virtual Expr *             visit( const GenericExpr          * ) override final;
    149         virtual Type *             visit( const VoidType             * ) override final;
    150         virtual Type *             visit( const BasicType            * ) override final;
    151         virtual Type *             visit( const PointerType          * ) override final;
    152         virtual Type *             visit( const ArrayType            * ) override final;
    153         virtual Type *             visit( const ReferenceType        * ) override final;
    154         virtual Type *             visit( const QualifiedType        * ) override final;
    155         virtual Type *             visit( const FunctionType         * ) override final;
    156         virtual Type *             visit( const StructInstType       * ) override final;
    157         virtual Type *             visit( const UnionInstType        * ) override final;
    158         virtual Type *             visit( const EnumInstType         * ) override final;
    159         virtual Type *             visit( const TraitInstType        * ) override final;
    160         virtual Type *             visit( const TypeInstType         * ) override final;
    161         virtual Type *             visit( const TupleType            * ) override final;
    162         virtual Type *             visit( const TypeofType           * ) override final;
    163         virtual Type *             visit( const AttrType             * ) override final;
    164         virtual Type *             visit( const VarArgsType          * ) override final;
    165         virtual Type *             visit( const ZeroType             * ) override final;
    166         virtual Type *             visit( const OneType              * ) override final;
    167         virtual Type *             visit( const GlobalScopeType      * ) override final;
    168         virtual Designation *      visit( const Designation          * ) override final;
    169         virtual Init *             visit( const SingleInit           * ) override final;
    170         virtual Init *             visit( const ListInit             * ) override final;
    171         virtual Init *             visit( const ConstructorInit      * ) override final;
    172         virtual Constant *         visit( const Constant             * ) override final;
    173         virtual Attribute *        visit( const Attribute            * ) override final;
    174         virtual TypeSubstitution * visit( const TypeSubstitution     * ) override final;
     87        virtual const ast::DeclWithType *     visit( const ast::ObjectDecl           * ) override final;
     88        virtual const ast::DeclWithType *     visit( const ast::FunctionDecl         * ) override final;
     89        virtual const ast::Decl *             visit( const ast::StructDecl           * ) override final;
     90        virtual const ast::Decl *             visit( const ast::UnionDecl            * ) override final;
     91        virtual const ast::Decl *             visit( const ast::EnumDecl             * ) override final;
     92        virtual const ast::Decl *             visit( const ast::TraitDecl            * ) override final;
     93        virtual const ast::Decl *             visit( const ast::TypeDecl             * ) override final;
     94        virtual const ast::Decl *             visit( const ast::TypedefDecl          * ) override final;
     95        virtual const ast::AsmDecl *          visit( const ast::AsmDecl              * ) override final;
     96        virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) override final;
     97        virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) override final;
     98        virtual const ast::Stmt *             visit( const ast::ExprStmt             * ) override final;
     99        virtual const ast::Stmt *             visit( const ast::AsmStmt              * ) override final;
     100        virtual const ast::Stmt *             visit( const ast::DirectiveStmt        * ) override final;
     101        virtual const ast::Stmt *             visit( const ast::IfStmt               * ) override final;
     102        virtual const ast::Stmt *             visit( const ast::WhileStmt            * ) override final;
     103        virtual const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
     104        virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
     105        virtual const ast::Stmt *             visit( const ast::CaseStmt             * ) override final;
     106        virtual const ast::Stmt *             visit( const ast::BranchStmt           * ) override final;
     107        virtual const ast::Stmt *             visit( const ast::ReturnStmt           * ) override final;
     108        virtual const ast::Stmt *             visit( const ast::ThrowStmt            * ) override final;
     109        virtual const ast::Stmt *             visit( const ast::TryStmt              * ) override final;
     110        virtual const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
     111        virtual const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
     112        virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
     113        virtual const ast::Stmt *             visit( const ast::WithStmt             * ) override final;
     114        virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;
     115        virtual const ast::Stmt *             visit( const ast::DeclStmt             * ) override final;
     116        virtual const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) override final;
     117        virtual const ast::Expr *             visit( const ast::ApplicationExpr      * ) override final;
     118        virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;
     119        virtual const ast::Expr *             visit( const ast::NameExpr             * ) override final;
     120        virtual const ast::Expr *             visit( const ast::AddressExpr          * ) override final;
     121        virtual const ast::Expr *             visit( const ast::LabelAddressExpr     * ) override final;
     122        virtual const ast::Expr *             visit( const ast::CastExpr             * ) override final;
     123        virtual const ast::Expr *             visit( const ast::KeywordCastExpr      * ) override final;
     124        virtual const ast::Expr *             visit( const ast::VirtualCastExpr      * ) override final;
     125        virtual const ast::Expr *             visit( const ast::UntypedMemberExpr    * ) override final;
     126        virtual const ast::Expr *             visit( const ast::MemberExpr           * ) override final;
     127        virtual const ast::Expr *             visit( const ast::VariableExpr         * ) override final;
     128        virtual const ast::Expr *             visit( const ast::ConstantExpr         * ) override final;
     129        virtual const ast::Expr *             visit( const ast::SizeofExpr           * ) override final;
     130        virtual const ast::Expr *             visit( const ast::AlignofExpr          * ) override final;
     131        virtual const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) override final;
     132        virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) override final;
     133        virtual const ast::Expr *             visit( const ast::OffsetPackExpr       * ) override final;
     134        virtual const ast::Expr *             visit( const ast::AttrExpr             * ) override final;
     135        virtual const ast::Expr *             visit( const ast::LogicalExpr          * ) override final;
     136        virtual const ast::Expr *             visit( const ast::ConditionalExpr      * ) override final;
     137        virtual const ast::Expr *             visit( const ast::CommaExpr            * ) override final;
     138        virtual const ast::Expr *             visit( const ast::TypeExpr             * ) override final;
     139        virtual const ast::Expr *             visit( const ast::AsmExpr              * ) override final;
     140        virtual const ast::Expr *             visit( const ast::ImplicitCopyCtorExpr * ) override final;
     141        virtual const ast::Expr *             visit( const ast::ConstructorExpr      * ) override final;
     142        virtual const ast::Expr *             visit( const ast::CompoundLiteralExpr  * ) override final;
     143        virtual const ast::Expr *             visit( const ast::RangeExpr            * ) override final;
     144        virtual const ast::Expr *             visit( const ast::UntypedTupleExpr     * ) override final;
     145        virtual const ast::Expr *             visit( const ast::TupleExpr            * ) override final;
     146        virtual const ast::Expr *             visit( const ast::TupleIndexExpr       * ) override final;
     147        virtual const ast::Expr *             visit( const ast::TupleAssignExpr      * ) override final;
     148        virtual const ast::Expr *             visit( const ast::StmtExpr             * ) override final;
     149        virtual const ast::Expr *             visit( const ast::UniqueExpr           * ) override final;
     150        virtual const ast::Expr *             visit( const ast::UntypedInitExpr      * ) override final;
     151        virtual const ast::Expr *             visit( const ast::InitExpr             * ) override final;
     152        virtual const ast::Expr *             visit( const ast::DeletedExpr          * ) override final;
     153        virtual const ast::Expr *             visit( const ast::DefaultArgExpr       * ) override final;
     154        virtual const ast::Expr *             visit( const ast::GenericExpr          * ) override final;
     155        virtual const ast::Type *             visit( const ast::VoidType             * ) override final;
     156        virtual const ast::Type *             visit( const ast::BasicType            * ) override final;
     157        virtual const ast::Type *             visit( const ast::PointerType          * ) override final;
     158        virtual const ast::Type *             visit( const ast::ArrayType            * ) override final;
     159        virtual const ast::Type *             visit( const ast::ReferenceType        * ) override final;
     160        virtual const ast::Type *             visit( const ast::QualifiedType        * ) override final;
     161        virtual const ast::Type *             visit( const ast::FunctionType         * ) override final;
     162        virtual const ast::Type *             visit( const ast::StructInstType       * ) override final;
     163        virtual const ast::Type *             visit( const ast::UnionInstType        * ) override final;
     164        virtual const ast::Type *             visit( const ast::EnumInstType         * ) override final;
     165        virtual const ast::Type *             visit( const ast::TraitInstType        * ) override final;
     166        virtual const ast::Type *             visit( const ast::TypeInstType         * ) override final;
     167        virtual const ast::Type *             visit( const ast::TupleType            * ) override final;
     168        virtual const ast::Type *             visit( const ast::TypeofType           * ) override final;
     169        virtual const ast::Type *             visit( const ast::AttrType             * ) override final;
     170        virtual const ast::Type *             visit( const ast::VarArgsType          * ) override final;
     171        virtual const ast::Type *             visit( const ast::ZeroType             * ) override final;
     172        virtual const ast::Type *             visit( const ast::OneType              * ) override final;
     173        virtual const ast::Type *             visit( const ast::GlobalScopeType      * ) override final;
     174        virtual const ast::Designation *      visit( const ast::Designation          * ) override final;
     175        virtual const ast::Init *             visit( const ast::SingleInit           * ) override final;
     176        virtual const ast::Init *             visit( const ast::ListInit             * ) override final;
     177        virtual const ast::Init *             visit( const ast::ConstructorInit      * ) override final;
     178        virtual const ast::Constant *         visit( const ast::Constant             * ) override final;
     179        virtual const ast::Attribute *        visit( const ast::Attribute            * ) override final;
     180        virtual const ast::TypeSubstitution * visit( const ast::TypeSubstitution     * ) override final;
    175181
    176182        friend void acceptAll( std::list< ptr<Decl> > & decls, Pass<pass_t>& visitor );
     
    180186
    181187private:
     188        const ast::Stmt * call_accept( const ast::Stmt * );
     189        const ast::Expr * call_accept( const ast::Expr * );
     190
     191        template< typename node_t >
     192        auto call_accept( const node_t * node ) -> decltype( node->accept(*this) );
     193
     194        template< template <class...> class container_t >
     195        container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & );
     196
     197        template< template <class...> class container_t, typename node_t >
     198        container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
     199
    182200        /// Logic to call the accept and mutate the parent if needed, delegates call to accept
    183         template<typename parent_t, typename child_t>
    184         void maybe_accept(parent_t * & , typename parent_t::child_t *);
    185 
    186         Stmt * call_accept( const Stmt * );
    187         Expr * call_accept( const Expr * );
    188 
    189         template< template <class> class container_t >
    190         container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & );
    191 
    192         template< template <class> class container_t, typename node_t >
    193         container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
     201        template<typename node_t, typename parent_t, typename child_t>
     202        void maybe_accept(const node_t * &, child_t parent_t::* child);
    194203
    195204private:
     
    210219
    211220template<typename pass_t>
    212 void acceptAll( std::list< ptr<Decl> >, Pass<pass_t>& visitor );
     221void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor );
    213222
    214223//-------------------------------------------------------------------------------------------------
     
    216225//-------------------------------------------------------------------------------------------------
    217226
    218 template<typename T>
    219 using std_list = std::list<T>;
    220 
    221227/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
    222228struct WithConstTypeSubstitution {
     
    226232/// Used if visitor requires added statements before or after the current node.
    227233/// The Pass template handles what *before* and *after* means automatically
    228 template< template<class> class container_t = std_list >
     234template< template<class...> class container_t = std::list >
    229235struct WithStmtsToAdd {
    230236        container_t< ptr<Stmt> > stmtsToAddBefore;
     
    234240/// Used if visitor requires added declarations before or after the current node.
    235241/// The Pass template handles what *before* and *after* means automatically
    236 template< template<class> class container_t = std_list >
     242template< template<class...> class container_t = std::list >
    237243struct WithDeclsToAdd {
    238244        container_t< ptr<Decl> > declsToAddBefore;
     
    286292};
    287293}
     294
     295#include "Common/Stats.h"
     296
     297extern struct PassVisitorStats {
     298        size_t depth = 0;
     299        Stats::Counters::MaxCounter<double> * max = nullptr;
     300        Stats::Counters::AverageCounter<double> * avg = nullptr;
     301} pass_visitor_stats;
     302
     303#include "AST/Pass.impl.hpp"
  • src/AST/Pass.impl.hpp

    r712348a r6d51bd7  
    1616#pragma once
    1717// IWYU pragma: private, include "AST/Pass.hpp"
     18
     19#include <type_traits>
     20#include <unordered_map>
    1821
    1922#define VISIT_START( node ) \
     
    2629        __pass::previsit( pass, node, 0 );
    2730
    28 #define VISIT( code ) \
     31#define VISIT( code... ) \
    2932        /* if this node should visit its children */ \
    3033        if ( __visit_children() ) { \
     
    3538#define VISIT_END( type, node ) \
    3639        /* call the implementation of the postvisit of this pass */ \
    37         auto __return = __pass::postvisit< type * >( node ); \
     40        auto __return = __pass::postvisit( pass, node, 0 ); \
    3841        assertf(__return, "post visit should never return null"); \
    3942        return __return;
    4043
    4144#ifdef PEDANTIC_PASS_ASSERT
    42 #define __pedantic_pass_assert (...) assert (__VAR_ARGS__)
    43 #define __pedantic_pass_assertf(...) assertf(__VAR_ARGS__)
     45#define __pedantic_pass_assert(...) assert (__VA_ARGS__)
     46#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
    4447#else
    45 #define __pedantic_pass_assert (...)
     48#define __pedantic_pass_assert(...)
    4649#define __pedantic_pass_assertf(...)
    4750#endif
     
    5558                }
    5659
    57                 template<typename it_t, template <class> class container_t>
    58                 static inline void take_all( it_t it, container_t<ast::ptr<ast::Declaration>> * decls, bool * mutated = nullptr ) {
     60                //------------------------------
     61                template<typename it_t, template <class...> class container_t>
     62                static inline void take_all( it_t it, container_t<ast::ptr<ast::Decl>> * decls, bool * mutated = nullptr ) {
    5963                        if(empty(decls)) return;
    6064
    61                         std::transform(decls->begin(), decls->end(), it, [](Declaration * decl) -> auto {
     65                        std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto {
    6266                                        return new DeclStmt( decl );
    6367                                });
     
    6670                }
    6771
    68                 template<typename it_t, template <class> class container_t>
    69                 static inline void take_all( it_t it, container_t<ast::ptr<ast::Statement>> * decls, bool * mutated = nullptr ) {
     72                template<typename it_t, template <class...> class container_t>
     73                static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * decls, bool * mutated = nullptr ) {
    7074                        if(empty(decls)) return;
    7175
     
    7579                }
    7680
     81                //------------------------------
     82                /// Check if should be skipped, different for pointers and containers
    7783                template<typename node_t>
    78                 bool differs( const node_t * old_val, const node_t * new_val ) {
     84                bool skip( const ast::ptr<node_t> & val) {
     85                        return !val;
     86                }
     87
     88                template< template <class...> class container_t, typename node_t >
     89                bool skip( const container_t<ast::ptr< node_t >> & val ) {
     90                        return val.empty();
     91                }
     92
     93                //------------------------------
     94                /// Get the value to visit, different for pointers and containers
     95                template<typename node_t>
     96                auto get( const ast::ptr<node_t> & val, int ) -> decltype(val.get()) {
     97                        return val.get();
     98                }
     99
     100                template<typename node_t>
     101                const node_t & get( const node_t & val, long) {
     102                        return val;
     103                }
     104
     105
     106                //------------------------------
     107                /// Check if value was mutated, different for pointers and containers
     108                template<typename lhs_t, typename rhs_t>
     109                bool differs( const lhs_t * old_val, const rhs_t * new_val ) {
    79110                        return old_val != new_val;
    80111                }
    81112
    82                 template< template <class> class container_t >
    83                 bool differs( const container_t<ast::ptr< ast::Statement >> &, const container_t<ast::ptr< ast::Statement >> & new_val ) {
     113                template< template <class...> class container_t, typename node_t >
     114                bool differs( const container_t<ast::ptr< node_t >> &, const container_t<ast::ptr< node_t >> & new_val ) {
    84115                        return !new_val.empty();
    85                 }
    86         }
    87 
    88         template<typename parent_t, typename child_t>
    89         template< typename pass_t >
    90         void Pass< pass_t >::maybe_accept(
    91                 const parent_t * & parent,
    92                 const typename parent_t::child_t * child
    93         ) {
    94                 const auto & old_val = parent->*child;
    95                 if(!old_val) return;
    96 
    97                 auto new_val = call_accept(old_val);
    98 
    99                 if( __pass::differs(old_val, new_val) ) {
    100                         auto new_parent = mutate(parent);
    101                         new_parent->*child = new_val;
    102                         parent = new_parent;
    103116                }
    104117        }
     
    106119        template< typename pass_t >
    107120        template< typename node_t >
    108         auto Pass< pass_t >::call_accept( const node_t * node ) {
     121        auto Pass< pass_t >::call_accept( const node_t * node ) -> decltype( node->accept(*this) ) {
    109122                __pedantic_pass_assert( __visit_children() );
    110123                __pedantic_pass_assert( expr );
    111124
     125                static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
     126                static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR");
     127
    112128                return node->accept( *this );
    113129        }
    114130
    115131        template< typename pass_t >
    116         ast::Expr * Pass< pass_t >::call_accept( const ast::Expr * expr ) {
     132        const ast::Expr * Pass< pass_t >::call_accept( const ast::Expr * expr ) {
    117133                __pedantic_pass_assert( __visit_children() );
    118134                __pedantic_pass_assert( expr );
     
    127143
    128144        template< typename pass_t >
    129         Stmt * Pass< pass_t >::call_accept( const Stmt * stmt ) {
     145        const ast::Stmt * Pass< pass_t >::call_accept( const ast::Stmt * stmt ) {
    130146                __pedantic_pass_assert( __visit_children() );
    131147                __pedantic_pass_assert( stmt );
     
    141157
    142158                // These may be modified by subnode but most be restored once we exit this statemnet.
    143                 ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( pass, 0); );
    144                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) > __old_decls_before( stmts_before );
    145                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) > __old_decls_after ( stmts_after  );
    146                 ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) > __old_stmts_before( decls_before );
    147                 ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) > __old_stmts_after ( decls_after  );
     159                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( pass, 0) );
     160                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) > > __old_decls_before( stmts_before );
     161                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) > > __old_decls_after ( stmts_after  );
     162                ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) > > __old_stmts_before( decls_before );
     163                ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) > > __old_stmts_after ( decls_after  );
    148164
    149165                // Now is the time to actually visit the node
    150                 ast::Statement * nstmt = stmt->accept( *this );
     166                const ast::Stmt * nstmt = stmt->accept( *this );
    151167
    152168                // If the pass doesn't want to add anything then we are done
     
    161177
    162178                // Create a new Compound Statement to hold the new decls/stmts
    163                 ast::CompoundStmt * compound = new ast::CompoundStmt( parent->*child.location );
     179                ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
    164180
    165181                // Take all the declarations that go before
     
    168184
    169185                // Insert the original declaration
    170                 compound->kids.push_back( nstmt );
     186                compound->kids.emplace_back( nstmt );
    171187
    172188                // Insert all the declarations that go before
     
    178194
    179195        template< typename pass_t >
    180         template< template <class> class container_t >
     196        template< template <class...> class container_t >
    181197        container_t< ptr<Stmt> > Pass< pass_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
    182198                __pedantic_pass_assert( __visit_children() );
     
    196212
    197213                // These may be modified by subnode but most be restored once we exit this statemnet.
    198                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) > __old_decls_before( stmts_before );
    199                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) > __old_decls_after ( stmts_after  );
    200                 ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) > __old_stmts_before( decls_before );
    201                 ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) > __old_stmts_after ( decls_after  );
     214                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) > > __old_decls_before( stmts_before );
     215                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) > > __old_decls_after ( stmts_after  );
     216                ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) > > __old_stmts_before( decls_before );
     217                ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) > > __old_stmts_after ( decls_after  );
    202218
    203219                // update pass statitistics
     
    211227                        try {
    212228                                __pedantic_pass_assert( stmt );
    213                                 const ast::Statment * new_stmt = stmt->accept( visitor );
     229                                const ast::Stmt * new_stmt = stmt->accept( *this );
    214230                                assert( new_stmt );
    215231                                if(new_stmt != stmt ) mutated = true;
     
    240256                if ( !errors.isEmpty() ) { throw errors; }
    241257
    242                 return mutated ? new_kids : {};
     258                return mutated ? new_kids : container_t< ptr<Stmt> >();
    243259        }
    244260
    245261        template< typename pass_t >
    246         template< template <class> class container_t, typename node_t >
     262        template< template <class...> class container_t, typename node_t >
    247263        container_t< ast::ptr<node_t> > Pass< pass_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
    248264                __pedantic_pass_assert( __visit_children() );
     
    259275                        try {
    260276                                __pedantic_pass_assert( node );
    261                                 const node_t * new_node = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
    262                                 if(new_stmt != stmt ) mutated = true;
     277                                const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
     278                                if(new_stmt != node ) mutated = true;
    263279
    264280                                new_kids.emplace_back( new_stmt );
     
    271287                if ( ! errors.isEmpty() ) { throw errors; }
    272288
    273                 return mutated ? new_kids : {};
    274         }
     289                return mutated ? new_kids : container_t< ast::ptr<node_t> >();
     290        }
     291
     292        template< typename pass_t >
     293        template<typename node_t, typename parent_t, typename child_t>
     294        void Pass< pass_t >::maybe_accept(
     295                const node_t * & parent,
     296                child_t parent_t::*child
     297        ) {
     298                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deductiing member object" );
     299
     300                if(__pass::skip(parent->*child)) return;
     301                const auto & old_val = __pass::get(parent->*child, 0);
     302
     303                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
     304
     305                auto new_val = call_accept( old_val );
     306
     307                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
     308
     309                if( __pass::differs(old_val, new_val) ) {
     310                        auto new_parent = mutate(parent);
     311                        new_parent->*child = new_val;
     312                        parent = new_parent;
     313                }
     314        }
     315
    275316}
    276317
     
    284325
    285326template< typename pass_t >
    286 inline void ast::acceptAll( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< pass_t > & visitor ) {
     327inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< pass_t > & visitor ) {
    287328        // We are going to aggregate errors for all these statements
    288329        SemanticErrorException errors;
     
    292333
    293334        // get the stmts/decls that will need to be spliced in
    294         auto decls_before = __pass::declsToAddBefore( pass, 0);
    295         auto decls_after  = __pass::declsToAddAfter ( pass, 0);
     335        auto decls_before = __pass::declsToAddBefore( visitor.pass, 0);
     336        auto decls_after  = __pass::declsToAddAfter ( visitor.pass, 0);
    296337
    297338        // update pass statitistics
     
    343384// ObjectDecl
    344385template< typename pass_t >
    345 ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::ObjectDecl * node ) {
     386const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::ObjectDecl * node ) {
    346387        VISIT_START( node );
    347388
    348389        VISIT(
    349390                {
    350                         indexer_guard guard { *this };
    351                         maybe_accept( node, ObjectDecl::type );
    352                 }
    353                 maybe_accept( node, ObjectDecl::init          );
    354                 maybe_accept( node, ObjectDecl::bitfieldWidth );
    355                 maybe_accept( node, ObjectDecl::attributes    );
     391                        guard_indexer guard { *this };
     392                        maybe_accept( node, &ast::ObjectDecl::type );
     393                }
     394                maybe_accept( node, &ast::ObjectDecl::init          );
     395                maybe_accept( node, &ast::ObjectDecl::bitfieldWidth );
     396                maybe_accept( node, &ast::ObjectDecl::attributes    );
    356397        )
    357398
    358         __pass::indexer::AddId( pass, 0, node );
     399        __pass::indexer::addId( pass, 0, node );
    359400
    360401        VISIT_END( DeclWithType, node );
     402}
     403
     404//--------------------------------------------------------------------------
     405// SingleInit
     406template< typename pass_t >
     407const ast::Init * ast::Pass< pass_t >::visit( const ast::SingleInit * node ) {
     408        VISIT_START( node );
     409
     410        VISIT(
     411                maybe_accept( node, &SingleInit::value );
     412        )
     413
     414        VISIT_END( Init, node );
     415}
     416
     417//--------------------------------------------------------------------------
     418// ListInit
     419template< typename pass_t >
     420const ast::Init * ast::Pass< pass_t >::visit( const ast::ListInit * node ) {
     421        VISIT_START( node );
     422
     423        VISIT(
     424                maybe_accept( node, &ListInit::designations );
     425                maybe_accept( node, &ListInit::initializers );
     426        )
     427
     428        VISIT_END( Init, node );
     429}
     430
     431//--------------------------------------------------------------------------
     432// ConstructorInit
     433template< typename pass_t >
     434const ast::Init * ast::Pass< pass_t >::visit( const ast::ConstructorInit * node ) {
     435        VISIT_START( node );
     436
     437        VISIT(
     438                maybe_accept( node, &ConstructorInit::ctor );
     439                maybe_accept( node, &ConstructorInit::dtor );
     440                maybe_accept( node, &ConstructorInit::init );
     441        )
     442
     443        VISIT_END( Init, node );
    361444}
    362445
    363446//--------------------------------------------------------------------------
    364447// Attribute
    365 template< typename pass_type >
    366 ast::Attribute * ast::Pass< pass_type >::visit( const ast::Attribute * node  )  {
    367         VISIT_START(node);
     448template< typename pass_t >
     449const ast::Attribute * ast::Pass< pass_t >::visit( const ast::Attribute * node  )  {
     450        VISIT_START( node );
    368451
    369452        VISIT(
    370                 maybe_accept( node, ast::Attribute::parameters );
     453                maybe_accept( node, &Attribute::parameters );
    371454        )
    372455
    373         VISIT_END(ast::Attribute *, node );
     456        VISIT_END( Attribute *, node );
    374457}
    375458
    376459//--------------------------------------------------------------------------
    377460// TypeSubstitution
    378 template< typename pass_type >
    379 TypeSubstitution * PassVisitor< pass_type >::mutate( const TypeSubstitution * node ) {
    380         MUTATE_START( node );
    381 
    382         #error this is broken
    383 
    384         for ( auto & p : node->typeEnv ) {
    385                 indexerScopedMutate( p.second, *this );
    386         }
    387         for ( auto & p : node->varEnv ) {
    388                 indexerScopedMutate( p.second, *this );
    389         }
    390 
    391         MUTATE_END( TypeSubstitution, node );
     461template< typename pass_t >
     462const ast::TypeSubstitution * ast::Pass< pass_t >::visit( const ast::TypeSubstitution * node ) {
     463        VISIT_START( node );
     464
     465        VISIT(
     466                {
     467                        bool mutated = false;
     468                        std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
     469                        for ( const auto & p : node->typeEnv ) {
     470                                guard_indexer guard { *this };
     471                                auto new_node = p.second->accept( *this );
     472                                if (new_node != p.second) mutated = false;
     473                                new_map.insert({ p.first, new_node });
     474                        }
     475                        if (mutated) {
     476                                auto new_node = mutate( node );
     477                                new_node->typeEnv.swap( new_map );
     478                                node = new_node;
     479                        }
     480                }
     481
     482                {
     483                        bool mutated = false;
     484                        std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
     485                        for ( const auto & p : node->varEnv ) {
     486                                guard_indexer guard { *this };
     487                                auto new_node = p.second->accept( *this );
     488                                if (new_node != p.second) mutated = false;
     489                                new_map.insert({ p.first, new_node });
     490                        }
     491                        if (mutated) {
     492                                auto new_node = mutate( node );
     493                                new_node->varEnv.swap( new_map );
     494                                node = new_node;
     495                        }
     496                }
     497        )
     498
     499        VISIT_END( TypeSubstitution, node );
    392500}
    393501
  • src/AST/Pass.proto.hpp

    r712348a r6d51bd7  
    162162
    163163        // List of fields and their expected types
    164         FIELD_PTR( env, const ast::TypeSubstitution )
     164        FIELD_PTR( env, const ast::TypeSubstitution * )
    165165        FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
    166166        FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
     
    235235                static inline void func( pass_t &, long, type1, type2 ) {}
    236236
    237                 INDEXER_FUNC1( addId     , DeclWithType *  );
    238                 INDEXER_FUNC1( addType   , NamedTypeDecl * );
    239                 INDEXER_FUNC1( addStruct , StructDecl *    );
    240                 INDEXER_FUNC1( addEnum   , EnumDecl *      );
    241                 INDEXER_FUNC1( addUnion  , UnionDecl *     );
    242                 INDEXER_FUNC1( addTrait  , TraitDecl *     );
    243                 INDEXER_FUNC2( addWith   , std::list< Expression * > &, Node * );
     237                INDEXER_FUNC1( addId     , const DeclWithType *  );
     238                INDEXER_FUNC1( addType   , const NamedTypeDecl * );
     239                INDEXER_FUNC1( addStruct , const StructDecl *    );
     240                INDEXER_FUNC1( addEnum   , const EnumDecl *      );
     241                INDEXER_FUNC1( addUnion  , const UnionDecl *     );
     242                INDEXER_FUNC1( addTrait  , const TraitDecl *     );
     243                INDEXER_FUNC2( addWith   , const std::list< Expression * > &, const Node * );
    244244
    245245                // A few extra functions have more complicated behaviour, they are hand written
    246                 // template<typename pass_t>
    247                 // static inline auto addStructFwd( pass_t & pass, int, ast::StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
    248                 //      ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
    249                 //      fwd->parameters = decl->parameters;
    250                 //      pass.indexer.addStruct( fwd );
    251                 // }
    252 
    253                 // template<typename pass_t>
    254                 // static inline void addStructFwd( pass_t &, long, ast::StructDecl * ) {}
    255 
    256                 // template<typename pass_t>
    257                 // static inline auto addUnionFwd( pass_t & pass, int, ast::UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
    258                 //      UnionDecl * fwd = new UnionDecl( decl->name );
    259                 //      fwd->parameters = decl->parameters;
    260                 //      pass.indexer.addUnion( fwd );
    261                 // }
    262 
    263                 // template<typename pass_t>
    264                 // static inline void addUnionFwd( pass_t &, long, ast::UnionDecl * ) {}
    265 
    266                 // template<typename pass_t>
    267                 // static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addStruct( str ), void() ) {
    268                 //      if ( ! pass.indexer.lookupStruct( str ) ) {
    269                 //              pass.indexer.addStruct( str );
    270                 //      }
    271                 // }
    272 
    273                 // template<typename pass_t>
    274                 // static inline void addStruct( pass_t &, long, const std::string & ) {}
    275 
    276                 // template<typename pass_t>
    277                 // static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) {
    278                 //      if ( ! pass.indexer.lookupUnion( str ) ) {
    279                 //              pass.indexer.addUnion( str );
    280                 //      }
    281                 // }
    282 
    283                 // template<typename pass_t>
    284                 // static inline void addUnion( pass_t &, long, const std::string & ) {}
     246                template<typename pass_t>
     247                static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
     248                        ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
     249                        fwd->parameters = decl->parameters;
     250                        pass.indexer.addStruct( fwd );
     251                }
     252
     253                template<typename pass_t>
     254                static inline void addStructFwd( pass_t &, long, const ast::StructDecl * ) {}
     255
     256                template<typename pass_t>
     257                static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
     258                        UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
     259                        fwd->parameters = decl->parameters;
     260                        pass.indexer.addUnion( fwd );
     261                }
     262
     263                template<typename pass_t>
     264                static inline void addUnionFwd( pass_t &, long, const ast::UnionDecl * ) {}
     265
     266                template<typename pass_t>
     267                static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addStruct( str ), void() ) {
     268                        if ( ! pass.indexer.lookupStruct( str ) ) {
     269                                pass.indexer.addStruct( str );
     270                        }
     271                }
     272
     273                template<typename pass_t>
     274                static inline void addStruct( pass_t &, long, const std::string & ) {}
     275
     276                template<typename pass_t>
     277                static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) {
     278                        if ( ! pass.indexer.lookupUnion( str ) ) {
     279                                pass.indexer.addUnion( str );
     280                        }
     281                }
     282
     283                template<typename pass_t>
     284                static inline void addUnion( pass_t &, long, const std::string & ) {}
    285285
    286286                #undef INDEXER_FUNC1
  • src/AST/Stmt.hpp

    r712348a r6d51bd7  
    4040        Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
    4141
    42         virtual Stmt* accept( Visitor& v ) override = 0;
     42        virtual const Stmt* accept( Visitor& v ) const override = 0;
    4343private:
    4444        virtual Stmt* clone() const override = 0;
     
    5959        void push_front( Stmt* s ) { kids.emplace_front( s ); }
    6060
    61         CompoundStmt* accept( Visitor& v ) override { return v.visit( this ); }
     61        virtual const CompoundStmt* accept( Visitor& v ) const override { return v.visit( this ); }
    6262private:
    63         CompoundStmt* clone() const override { return new CompoundStmt{ *this }; }
     63        virtual CompoundStmt* clone() const override { return new CompoundStmt{ *this }; }
    6464};
    6565
     
    7070        : Stmt(loc, std::move(labels)) {}
    7171
    72         NullStmt* accept( Visitor& v ) override { return v.visit( this ); }
     72        virtual const NullStmt * accept( Visitor& v ) const override { return v.visit( this ); }
    7373private:
    74         NullStmt* clone() const override { return new NullStmt{ *this }; }
     74        virtual NullStmt * clone() const override { return new NullStmt{ *this }; }
    7575};
    7676
     
    8282        ExprStmt( const CodeLocation& loc, Expr* e ) : Stmt(loc), expr(e) {}
    8383
    84         Stmt* accept( Visitor& v ) override { return v.visit( this ); }
     84        virtual const Stmt * accept( Visitor& v ) const override { return v.visit( this ); }
    8585private:
    86         ExprStmt* clone() const override { return new ExprStmt{ *this }; }
     86        virtual ExprStmt * clone() const override { return new ExprStmt{ *this }; }
    8787};
    8888
     
    100100inline void increment( const class ExprStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    101101inline void decrement( const class ExprStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    102 inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    103 inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    104 inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    105 inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    106 inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    107 inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    108 inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    109 inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    110 inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    111 inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    112 inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    113 inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    114 inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    115 inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    116 inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    117 inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    118 inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    119 inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    120 inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    121 inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    122 inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    123 inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    124 inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    125 inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    126 inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    127 inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    128 inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    129 inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    130 inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    131 inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    132 inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    133 inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     102// inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     103// inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     104// inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     105// inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     106// inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     107// inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     108// inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     109// inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     110// inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     111// inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     112// inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     113// inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     114// inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     115// inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     116// inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     117// inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     118// inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     119// inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     120// inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     121// inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     122// inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     123// inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     124// inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     125// inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     126// inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     127// inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     128// inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     129// inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     130// inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     131// inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     132// inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     133// inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    134134inline void increment( const class NullStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    135135inline void decrement( const class NullStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    136 inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); }
    137 inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
     136// inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); }
     137// inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
    138138
    139139}
  • src/AST/Type.hpp

    r712348a r6d51bd7  
    2121
    2222class Type : public Node {
    23 
     23public:
     24virtual const Type * accept( Visitor & v) const = 0;
    2425};
    2526
     
    3132/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
    3233/// forward declarations
    33 inline void increment( const class Type * node, Node::ref_type ref ) { node->increment( ref ); }
    34 inline void decrement( const class Type * node, Node::ref_type ref ) { node->decrement( ref ); }
    35 inline void increment( const class VoidType * node, Node::ref_type ref ) { node->increment( ref ); }
    36 inline void decrement( const class VoidType * node, Node::ref_type ref ) { node->decrement( ref ); }
    37 inline void increment( const class BasicType * node, Node::ref_type ref ) { node->increment( ref ); }
    38 inline void decrement( const class BasicType * node, Node::ref_type ref ) { node->decrement( ref ); }
    39 inline void increment( const class PointerType * node, Node::ref_type ref ) { node->increment( ref ); }
    40 inline void decrement( const class PointerType * node, Node::ref_type ref ) { node->decrement( ref ); }
    41 inline void increment( const class ArrayType * node, Node::ref_type ref ) { node->increment( ref ); }
    42 inline void decrement( const class ArrayType * node, Node::ref_type ref ) { node->decrement( ref ); }
    43 inline void increment( const class ReferenceType * node, Node::ref_type ref ) { node->increment( ref ); }
    44 inline void decrement( const class ReferenceType * node, Node::ref_type ref ) { node->decrement( ref ); }
    45 inline void increment( const class QualifiedType * node, Node::ref_type ref ) { node->increment( ref ); }
    46 inline void decrement( const class QualifiedType * node, Node::ref_type ref ) { node->decrement( ref ); }
    47 inline void increment( const class FunctionType * node, Node::ref_type ref ) { node->increment( ref ); }
    48 inline void decrement( const class FunctionType * node, Node::ref_type ref ) { node->decrement( ref ); }
    49 inline void increment( const class ReferenceToType * node, Node::ref_type ref ) { node->increment( ref ); }
    50 inline void decrement( const class ReferenceToType * node, Node::ref_type ref ) { node->decrement( ref ); }
    51 inline void increment( const class StructInstType * node, Node::ref_type ref ) { node->increment( ref ); }
    52 inline void decrement( const class StructInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
    53 inline void increment( const class UnionInstType * node, Node::ref_type ref ) { node->increment( ref ); }
    54 inline void decrement( const class UnionInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
    55 inline void increment( const class EnumInstType * node, Node::ref_type ref ) { node->increment( ref ); }
    56 inline void decrement( const class EnumInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
    57 inline void increment( const class TraitInstType * node, Node::ref_type ref ) { node->increment( ref ); }
    58 inline void decrement( const class TraitInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
    59 inline void increment( const class TypeInstType * node, Node::ref_type ref ) { node->increment( ref ); }
    60 inline void decrement( const class TypeInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
    61 inline void increment( const class TupleType * node, Node::ref_type ref ) { node->increment( ref ); }
    62 inline void decrement( const class TupleType * node, Node::ref_type ref ) { node->decrement( ref ); }
    63 inline void increment( const class TypeofType * node, Node::ref_type ref ) { node->increment( ref ); }
    64 inline void decrement( const class TypeofType * node, Node::ref_type ref ) { node->decrement( ref ); }
    65 inline void increment( const class AttrType * node, Node::ref_type ref ) { node->increment( ref ); }
    66 inline void decrement( const class AttrType * node, Node::ref_type ref ) { node->decrement( ref ); }
    67 inline void increment( const class VarArgsType * node, Node::ref_type ref ) { node->increment( ref ); }
    68 inline void decrement( const class VarArgsType * node, Node::ref_type ref ) { node->decrement( ref ); }
    69 inline void increment( const class ZeroType * node, Node::ref_type ref ) { node->increment( ref ); }
    70 inline void decrement( const class ZeroType * node, Node::ref_type ref ) { node->decrement( ref ); }
    71 inline void increment( const class OneType * node, Node::ref_type ref ) { node->increment( ref ); }
    72 inline void decrement( const class OneType * node, Node::ref_type ref ) { node->decrement( ref ); }
    73 inline void increment( const class GlobalScopeType * node, Node::ref_type ref ) { node->increment( ref ); }
    74 inline void decrement( const class GlobalScopeType * node, Node::ref_type ref ) { node->decrement( ref ); }
     34inline void increment( const class Type * /*node*/, Node::ref_type /*ref*/ ) { /*node->increment( ref );*/ }
     35inline void decrement( const class Type * /*node*/, Node::ref_type /*ref*/ ) { /*node->decrement( ref );*/ }
     36// inline void increment( const class VoidType * node, Node::ref_type ref ) { node->increment( ref ); }
     37// inline void decrement( const class VoidType * node, Node::ref_type ref ) { node->decrement( ref ); }
     38// inline void increment( const class BasicType * node, Node::ref_type ref ) { node->increment( ref ); }
     39// inline void decrement( const class BasicType * node, Node::ref_type ref ) { node->decrement( ref ); }
     40// inline void increment( const class PointerType * node, Node::ref_type ref ) { node->increment( ref ); }
     41// inline void decrement( const class PointerType * node, Node::ref_type ref ) { node->decrement( ref ); }
     42// inline void increment( const class ArrayType * node, Node::ref_type ref ) { node->increment( ref ); }
     43// inline void decrement( const class ArrayType * node, Node::ref_type ref ) { node->decrement( ref ); }
     44// inline void increment( const class ReferenceType * node, Node::ref_type ref ) { node->increment( ref ); }
     45// inline void decrement( const class ReferenceType * node, Node::ref_type ref ) { node->decrement( ref ); }
     46// inline void increment( const class QualifiedType * node, Node::ref_type ref ) { node->increment( ref ); }
     47// inline void decrement( const class QualifiedType * node, Node::ref_type ref ) { node->decrement( ref ); }
     48// inline void increment( const class FunctionType * node, Node::ref_type ref ) { node->increment( ref ); }
     49// inline void decrement( const class FunctionType * node, Node::ref_type ref ) { node->decrement( ref ); }
     50// inline void increment( const class ReferenceToType * node, Node::ref_type ref ) { node->increment( ref ); }
     51// inline void decrement( const class ReferenceToType * node, Node::ref_type ref ) { node->decrement( ref ); }
     52// inline void increment( const class StructInstType * node, Node::ref_type ref ) { node->increment( ref ); }
     53// inline void decrement( const class StructInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
     54// inline void increment( const class UnionInstType * node, Node::ref_type ref ) { node->increment( ref ); }
     55// inline void decrement( const class UnionInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
     56// inline void increment( const class EnumInstType * node, Node::ref_type ref ) { node->increment( ref ); }
     57// inline void decrement( const class EnumInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
     58// inline void increment( const class TraitInstType * node, Node::ref_type ref ) { node->increment( ref ); }
     59// inline void decrement( const class TraitInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
     60// inline void increment( const class TypeInstType * node, Node::ref_type ref ) { node->increment( ref ); }
     61// inline void decrement( const class TypeInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
     62// inline void increment( const class TupleType * node, Node::ref_type ref ) { node->increment( ref ); }
     63// inline void decrement( const class TupleType * node, Node::ref_type ref ) { node->decrement( ref ); }
     64// inline void increment( const class TypeofType * node, Node::ref_type ref ) { node->increment( ref ); }
     65// inline void decrement( const class TypeofType * node, Node::ref_type ref ) { node->decrement( ref ); }
     66// inline void increment( const class AttrType * node, Node::ref_type ref ) { node->increment( ref ); }
     67// inline void decrement( const class AttrType * node, Node::ref_type ref ) { node->decrement( ref ); }
     68// inline void increment( const class VarArgsType * node, Node::ref_type ref ) { node->increment( ref ); }
     69// inline void decrement( const class VarArgsType * node, Node::ref_type ref ) { node->decrement( ref ); }
     70// inline void increment( const class ZeroType * node, Node::ref_type ref ) { node->increment( ref ); }
     71// inline void decrement( const class ZeroType * node, Node::ref_type ref ) { node->decrement( ref ); }
     72// inline void increment( const class OneType * node, Node::ref_type ref ) { node->increment( ref ); }
     73// inline void decrement( const class OneType * node, Node::ref_type ref ) { node->decrement( ref ); }
     74// inline void increment( const class GlobalScopeType * node, Node::ref_type ref ) { node->increment( ref ); }
     75// inline void decrement( const class GlobalScopeType * node, Node::ref_type ref ) { node->decrement( ref ); }
    7576
    7677}
  • src/AST/Visitor.hpp

    r712348a r6d51bd7  
    2222class Visitor {
    2323public:
    24     virtual DeclWithType *     visit( const ObjectDecl           * ) = 0;
    25     virtual DeclWithType *     visit( const FunctionDecl         * ) = 0;
    26     virtual Decl *             visit( const StructDecl           * ) = 0;
    27     virtual Decl *             visit( const UnionDecl            * ) = 0;
    28     virtual Decl *             visit( const EnumDecl             * ) = 0;
    29     virtual Decl *             visit( const TraitDecl            * ) = 0;
    30     virtual Decl *             visit( const TypeDecl             * ) = 0;
    31     virtual Decl *             visit( const TypedefDecl          * ) = 0;
    32     virtual AsmDecl *          visit( const AsmDecl              * ) = 0;
    33     virtual StaticAssertDecl * visit( const StaticAssertDecl     * ) = 0;
    34     virtual CompoundStmt *     visit( const CompoundStmt         * ) = 0;
    35     virtual Stmt *             visit( const ExprStmt             * ) = 0;
    36     virtual Stmt *             visit( const AsmStmt              * ) = 0;
    37     virtual Stmt *             visit( const DirectiveStmt        * ) = 0;
    38     virtual Stmt *             visit( const IfStmt               * ) = 0;
    39     virtual Stmt *             visit( const WhileStmt            * ) = 0;
    40     virtual Stmt *             visit( const ForStmt              * ) = 0;
    41     virtual Stmt *             visit( const SwitchStmt           * ) = 0;
    42     virtual Stmt *             visit( const CaseStmt             * ) = 0;
    43     virtual Stmt *             visit( const BranchStmt           * ) = 0;
    44     virtual Stmt *             visit( const ReturnStmt           * ) = 0;
    45     virtual Stmt *             visit( const ThrowStmt            * ) = 0;
    46     virtual Stmt *             visit( const TryStmt              * ) = 0;
    47     virtual Stmt *             visit( const CatchStmt            * ) = 0;
    48     virtual Stmt *             visit( const FinallyStmt          * ) = 0;
    49     virtual Stmt *             visit( const WaitForStmt          * ) = 0;
    50     virtual Stmt *             visit( const WithStmt             * ) = 0;
    51     virtual NullStmt *         visit( const NullStmt             * ) = 0;
    52     virtual Stmt *             visit( const DeclStmt             * ) = 0;
    53     virtual Stmt *             visit( const ImplicitCtorDtorStmt * ) = 0;
    54     virtual Expr *             visit( const ApplicationExpr      * ) = 0;
    55     virtual Expr *             visit( const UntypedExpr          * ) = 0;
    56     virtual Expr *             visit( const NameExpr             * ) = 0;
    57     virtual Expr *             visit( const AddressExpr          * ) = 0;
    58     virtual Expr *             visit( const LabelAddressExpr     * ) = 0;
    59     virtual Expr *             visit( const CastExpr             * ) = 0;
    60     virtual Expr *             visit( const KeywordCastExpr      * ) = 0;
    61     virtual Expr *             visit( const VirtualCastExpr      * ) = 0;
    62     virtual Expr *             visit( const UntypedMemberExpr    * ) = 0;
    63     virtual Expr *             visit( const MemberExpr           * ) = 0;
    64     virtual Expr *             visit( const VariableExpr         * ) = 0;
    65     virtual Expr *             visit( const ConstantExpr         * ) = 0;
    66     virtual Expr *             visit( const SizeofExpr           * ) = 0;
    67     virtual Expr *             visit( const AlignofExpr          * ) = 0;
    68     virtual Expr *             visit( const UntypedOffsetofExpr  * ) = 0;
    69     virtual Expr *             visit( const OffsetofExpr         * ) = 0;
    70     virtual Expr *             visit( const OffsetPackExpr       * ) = 0;
    71     virtual Expr *             visit( const AttrExpr             * ) = 0;
    72     virtual Expr *             visit( const LogicalExpr          * ) = 0;
    73     virtual Expr *             visit( const ConditionalExpr      * ) = 0;
    74     virtual Expr *             visit( const CommaExpr            * ) = 0;
    75     virtual Expr *             visit( const TypeExpr             * ) = 0;
    76     virtual Expr *             visit( const AsmExpr              * ) = 0;
    77     virtual Expr *             visit( const ImplicitCopyCtorExpr * ) = 0;
    78     virtual Expr *             visit( const ConstructorExpr      * ) = 0;
    79     virtual Expr *             visit( const CompoundLiteralExpr  * ) = 0;
    80     virtual Expr *             visit( const RangeExpr            * ) = 0;
    81     virtual Expr *             visit( const UntypedTupleExpr     * ) = 0;
    82     virtual Expr *             visit( const TupleExpr            * ) = 0;
    83     virtual Expr *             visit( const TupleIndexExpr       * ) = 0;
    84     virtual Expr *             visit( const TupleAssignExpr      * ) = 0;
    85     virtual Expr *             visit( const StmtExpr             * ) = 0;
    86     virtual Expr *             visit( const UniqueExpr           * ) = 0;
    87     virtual Expr *             visit( const UntypedInitExpr      * ) = 0;
    88     virtual Expr *             visit( const InitExpr             * ) = 0;
    89     virtual Expr *             visit( const DeletedExpr          * ) = 0;
    90     virtual Expr *             visit( const DefaultArgExpr       * ) = 0;
    91     virtual Expr *             visit( const GenericExpr          * ) = 0;
    92     virtual Type *             visit( const VoidType             * ) = 0;
    93     virtual Type *             visit( const BasicType            * ) = 0;
    94     virtual Type *             visit( const PointerType          * ) = 0;
    95     virtual Type *             visit( const ArrayType            * ) = 0;
    96     virtual Type *             visit( const ReferenceType        * ) = 0;
    97     virtual Type *             visit( const QualifiedType        * ) = 0;
    98     virtual Type *             visit( const FunctionType         * ) = 0;
    99     virtual Type *             visit( const StructInstType       * ) = 0;
    100     virtual Type *             visit( const UnionInstType        * ) = 0;
    101     virtual Type *             visit( const EnumInstType         * ) = 0;
    102     virtual Type *             visit( const TraitInstType        * ) = 0;
    103     virtual Type *             visit( const TypeInstType         * ) = 0;
    104     virtual Type *             visit( const TupleType            * ) = 0;
    105     virtual Type *             visit( const TypeofType           * ) = 0;
    106     virtual Type *             visit( const AttrType             * ) = 0;
    107     virtual Type *             visit( const VarArgsType          * ) = 0;
    108     virtual Type *             visit( const ZeroType             * ) = 0;
    109     virtual Type *             visit( const OneType              * ) = 0;
    110     virtual Type *             visit( const GlobalScopeType      * ) = 0;
    111     virtual Designation *      visit( const Designation          * ) = 0;
    112     virtual Init *             visit( const SingleInit           * ) = 0;
    113     virtual Init *             visit( const ListInit             * ) = 0;
    114     virtual Init *             visit( const ConstructorInit      * ) = 0;
    115     virtual Constant *         visit( const Constant             * ) = 0;
    116     virtual Attribute *        visit( const Attribute            * ) = 0;
    117     virtual TypeSubstitution * visit( const TypeSubstitution     * ) = 0;
     24    virtual const ast::DeclWithType *     visit( const ast::ObjectDecl           * ) = 0;
     25    virtual const ast::DeclWithType *     visit( const ast::FunctionDecl         * ) = 0;
     26    virtual const ast::Decl *             visit( const ast::StructDecl           * ) = 0;
     27    virtual const ast::Decl *             visit( const ast::UnionDecl            * ) = 0;
     28    virtual const ast::Decl *             visit( const ast::EnumDecl             * ) = 0;
     29    virtual const ast::Decl *             visit( const ast::TraitDecl            * ) = 0;
     30    virtual const ast::Decl *             visit( const ast::TypeDecl             * ) = 0;
     31    virtual const ast::Decl *             visit( const ast::TypedefDecl          * ) = 0;
     32    virtual const ast::AsmDecl *          visit( const ast::AsmDecl              * ) = 0;
     33    virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) = 0;
     34    virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) = 0;
     35    virtual const ast::Stmt *             visit( const ast::ExprStmt             * ) = 0;
     36    virtual const ast::Stmt *             visit( const ast::AsmStmt              * ) = 0;
     37    virtual const ast::Stmt *             visit( const ast::DirectiveStmt        * ) = 0;
     38    virtual const ast::Stmt *             visit( const ast::IfStmt               * ) = 0;
     39    virtual const ast::Stmt *             visit( const ast::WhileStmt            * ) = 0;
     40    virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
     41    virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;
     42    virtual const ast::Stmt *             visit( const ast::CaseStmt             * ) = 0;
     43    virtual const ast::Stmt *             visit( const ast::BranchStmt           * ) = 0;
     44    virtual const ast::Stmt *             visit( const ast::ReturnStmt           * ) = 0;
     45    virtual const ast::Stmt *             visit( const ast::ThrowStmt            * ) = 0;
     46    virtual const ast::Stmt *             visit( const ast::TryStmt              * ) = 0;
     47    virtual const ast::Stmt *             visit( const ast::CatchStmt            * ) = 0;
     48    virtual const ast::Stmt *             visit( const ast::FinallyStmt          * ) = 0;
     49    virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
     50    virtual const ast::Stmt *             visit( const ast::WithStmt             * ) = 0;
     51    virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) = 0;
     52    virtual const ast::Stmt *             visit( const ast::DeclStmt             * ) = 0;
     53    virtual const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) = 0;
     54    virtual const ast::Expr *             visit( const ast::ApplicationExpr      * ) = 0;
     55    virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;
     56    virtual const ast::Expr *             visit( const ast::NameExpr             * ) = 0;
     57    virtual const ast::Expr *             visit( const ast::AddressExpr          * ) = 0;
     58    virtual const ast::Expr *             visit( const ast::LabelAddressExpr     * ) = 0;
     59    virtual const ast::Expr *             visit( const ast::CastExpr             * ) = 0;
     60    virtual const ast::Expr *             visit( const ast::KeywordCastExpr      * ) = 0;
     61    virtual const ast::Expr *             visit( const ast::VirtualCastExpr      * ) = 0;
     62    virtual const ast::Expr *             visit( const ast::UntypedMemberExpr    * ) = 0;
     63    virtual const ast::Expr *             visit( const ast::MemberExpr           * ) = 0;
     64    virtual const ast::Expr *             visit( const ast::VariableExpr         * ) = 0;
     65    virtual const ast::Expr *             visit( const ast::ConstantExpr         * ) = 0;
     66    virtual const ast::Expr *             visit( const ast::SizeofExpr           * ) = 0;
     67    virtual const ast::Expr *             visit( const ast::AlignofExpr          * ) = 0;
     68    virtual const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) = 0;
     69    virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) = 0;
     70    virtual const ast::Expr *             visit( const ast::OffsetPackExpr       * ) = 0;
     71    virtual const ast::Expr *             visit( const ast::AttrExpr             * ) = 0;
     72    virtual const ast::Expr *             visit( const ast::LogicalExpr          * ) = 0;
     73    virtual const ast::Expr *             visit( const ast::ConditionalExpr      * ) = 0;
     74    virtual const ast::Expr *             visit( const ast::CommaExpr            * ) = 0;
     75    virtual const ast::Expr *             visit( const ast::TypeExpr             * ) = 0;
     76    virtual const ast::Expr *             visit( const ast::AsmExpr              * ) = 0;
     77    virtual const ast::Expr *             visit( const ast::ImplicitCopyCtorExpr * ) = 0;
     78    virtual const ast::Expr *             visit( const ast::ConstructorExpr      * ) = 0;
     79    virtual const ast::Expr *             visit( const ast::CompoundLiteralExpr  * ) = 0;
     80    virtual const ast::Expr *             visit( const ast::RangeExpr            * ) = 0;
     81    virtual const ast::Expr *             visit( const ast::UntypedTupleExpr     * ) = 0;
     82    virtual const ast::Expr *             visit( const ast::TupleExpr            * ) = 0;
     83    virtual const ast::Expr *             visit( const ast::TupleIndexExpr       * ) = 0;
     84    virtual const ast::Expr *             visit( const ast::TupleAssignExpr      * ) = 0;
     85    virtual const ast::Expr *             visit( const ast::StmtExpr             * ) = 0;
     86    virtual const ast::Expr *             visit( const ast::UniqueExpr           * ) = 0;
     87    virtual const ast::Expr *             visit( const ast::UntypedInitExpr      * ) = 0;
     88    virtual const ast::Expr *             visit( const ast::InitExpr             * ) = 0;
     89    virtual const ast::Expr *             visit( const ast::DeletedExpr          * ) = 0;
     90    virtual const ast::Expr *             visit( const ast::DefaultArgExpr       * ) = 0;
     91    virtual const ast::Expr *             visit( const ast::GenericExpr          * ) = 0;
     92    virtual const ast::Type *             visit( const ast::VoidType             * ) = 0;
     93    virtual const ast::Type *             visit( const ast::BasicType            * ) = 0;
     94    virtual const ast::Type *             visit( const ast::PointerType          * ) = 0;
     95    virtual const ast::Type *             visit( const ast::ArrayType            * ) = 0;
     96    virtual const ast::Type *             visit( const ast::ReferenceType        * ) = 0;
     97    virtual const ast::Type *             visit( const ast::QualifiedType        * ) = 0;
     98    virtual const ast::Type *             visit( const ast::FunctionType         * ) = 0;
     99    virtual const ast::Type *             visit( const ast::StructInstType       * ) = 0;
     100    virtual const ast::Type *             visit( const ast::UnionInstType        * ) = 0;
     101    virtual const ast::Type *             visit( const ast::EnumInstType         * ) = 0;
     102    virtual const ast::Type *             visit( const ast::TraitInstType        * ) = 0;
     103    virtual const ast::Type *             visit( const ast::TypeInstType         * ) = 0;
     104    virtual const ast::Type *             visit( const ast::TupleType            * ) = 0;
     105    virtual const ast::Type *             visit( const ast::TypeofType           * ) = 0;
     106    virtual const ast::Type *             visit( const ast::AttrType             * ) = 0;
     107    virtual const ast::Type *             visit( const ast::VarArgsType          * ) = 0;
     108    virtual const ast::Type *             visit( const ast::ZeroType             * ) = 0;
     109    virtual const ast::Type *             visit( const ast::OneType              * ) = 0;
     110    virtual const ast::Type *             visit( const ast::GlobalScopeType      * ) = 0;
     111    virtual const ast::Designation *      visit( const ast::Designation          * ) = 0;
     112    virtual const ast::Init *             visit( const ast::SingleInit           * ) = 0;
     113    virtual const ast::Init *             visit( const ast::ListInit             * ) = 0;
     114    virtual const ast::Init *             visit( const ast::ConstructorInit      * ) = 0;
     115    virtual const ast::Constant *         visit( const ast::Constant             * ) = 0;
     116    virtual const ast::Attribute *        visit( const ast::Attribute            * ) = 0;
     117    virtual const ast::TypeSubstitution * visit( const ast::TypeSubstitution     * ) = 0;
    118118};
    119119
  • src/AST/porting.md

    r712348a r6d51bd7  
    88## Visitors ##
    99* `Visitor` and `Mutator` are combined into a single `ast::Visitor` class
    10   * Base nodes now override `Node* accept( Visitor& v ) = 0` with, e.g. `Stmt* accept( Visitor& v ) override = 0`
     10  * Base nodes now override `const Node * accept( Visitor & v ) const = 0` with, e.g. `const Stmt * accept( Visitor & v ) const override = 0`
    1111* `PassVisitor` is replaced with `ast::Pass`
    1212
     
    2424`clone` is private to `Node` now
    2525* still needs to be overriden to return appropriate type
    26   * e.g. `private: virtual Stmt* clone() const override = 0;`
     26  * e.g. `private: virtual Stmt * clone() const override = 0;`
     27  * because friendship is not inherited, all implementations of clone need
     28      /// Must be copied in ALL derived classes
     29      template<typename node_t>
     30      friend auto mutate(const node_t * node);
    2731
    2832All leaves of the `Node` inheritance tree are now declared `final`
Note: See TracChangeset for help on using the changeset viewer.