Changes in src/Common/PassVisitor.h [aff3af4:5d88a0a]

File:

• src/Common/PassVisitor.h (modified) (3 diffs)

src/Common/PassVisitor.h

@@ -1 +1 @@
 #pragma once
 
-#include <stack>
-
-#include "SynTree/Mutator.h"
 #include "SynTree/Visitor.h"
 
-#include "SynTree/Initializer.h"
-#include "SynTree/Statement.h"
-#include "SynTree/Type.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Constant.h"
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+//Deep magic (a.k.a template meta programming) to make the templated visitor work
+//Basically the goal is to make 2 previsit_impl
+// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of 
+//     'pass.previsit( node )' that compiles will be used for that node for that type
+//     This requires that this option only compile for passes that actually define an appropriate visit.
+//     SFINAE will make sure the compilation errors in this function don't halt the build.
+//     See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE
+// 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing.
+//     This is needed only to eliminate the need for passes to specify any kind of handlers.
+//     The second implementation only works because it has a lower priority. This is due to the bogus last parameter.
+//     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
+//     the first implementation takes priority in regards to overloading.
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+template<typename pass_type, typename node_type>
+static inline auto previsit_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.previsit( node ), void() ) {
+        pass.previsit( node );
+}
 
-#include "PassVisitor.proto.h"
+template<typename pass_type, typename node_type>
+static inline void previsit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {
+        //Do nothing
+}
+
+
+template<typename pass_type, typename node_type>
+static inline auto postvisit_impl( pass_type& pass, node_type * node, __attribute__((unused)) int unused ) ->decltype( pass.postvisit( node ), void() ) {
+        pass.postvisit( node );
+}
+
+template<typename pass_type, typename node_type>
+static inline auto postvisit_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) {
+        //Do nothing
+}
 
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -21 +44 @@
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 template< typename pass_type >
-class PassVisitor final : public Visitor, public Mutator {
+class PassVisitor final : public Visitor {
 public:
         PassVisitor() = default;
 
         template< typename... Args >
-        PassVisitor(Args &&... args)
+        PassVisitor(Args &&... args) 
                 : pass( std::forward<Args>( args )... )
         {}
 
         virtual ~PassVisitor() = default;
+private:
+        pass_type pass;
 
-        pass_type pass;
+public:
 
         virtual void visit( ObjectDecl *objectDecl ) override final;
@@ -120 +145 @@
         virtual void visit( Constant *constant ) override final;
 
-        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override final;
-        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override final;
-        virtual Declaration* mutate( StructDecl *aggregateDecl ) override final;
-        virtual Declaration* mutate( UnionDecl *aggregateDecl ) override final;
-        virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final;
-        virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final;
-        virtual TypeDecl* mutate( TypeDecl *typeDecl ) override final;
-        virtual Declaration* mutate( TypedefDecl *typeDecl ) override final;
-        virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final;
+private:
+        template<typename node_type> 
+        auto call_previsit ( node_type * node ) 
+                -> decltype( previsit_impl ( pass, node, 0 ), void() ) 
+        { 
+                previsit_impl ( pass, node, 0 ); 
+        }
 
-        virtual CompoundStmt* mutate( CompoundStmt *compoundStmt ) override final;
-        virtual Statement* mutate( ExprStmt *exprStmt ) override final;
-        virtual Statement* mutate( AsmStmt *asmStmt ) override final;
-        virtual Statement* mutate( IfStmt *ifStmt ) override final;
-        virtual Statement* mutate( WhileStmt *whileStmt ) override final;
-        virtual Statement* mutate( ForStmt *forStmt ) override final;
-        virtual Statement* mutate( SwitchStmt *switchStmt ) override final;
-        virtual Statement* mutate( CaseStmt *caseStmt ) override final;
-        virtual Statement* mutate( BranchStmt *branchStmt ) override final;
-        virtual Statement* mutate( ReturnStmt *returnStmt ) override final;
-        virtual Statement* mutate( TryStmt *returnStmt ) override final;
-        virtual Statement* mutate( CatchStmt *catchStmt ) override final;
-        virtual Statement* mutate( FinallyStmt *catchStmt ) override final;
-        virtual NullStmt* mutate( NullStmt *nullStmt ) override final;
-        virtual Statement* mutate( DeclStmt *declStmt ) override final;
-        virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final;
-
-        virtual Expression* mutate( ApplicationExpr *applicationExpr ) override final;
-        virtual Expression* mutate( UntypedExpr *untypedExpr ) override final;
-        virtual Expression* mutate( NameExpr *nameExpr ) override final;
-        virtual Expression* mutate( AddressExpr *castExpr ) override final;
-        virtual Expression* mutate( LabelAddressExpr *labAddressExpr ) override final;
-        virtual Expression* mutate( CastExpr *castExpr ) override final;
-        virtual Expression* mutate( UntypedMemberExpr *memberExpr ) override final;
-        virtual Expression* mutate( MemberExpr *memberExpr ) override final;
-        virtual Expression* mutate( VariableExpr *variableExpr ) override final;
-        virtual Expression* mutate( ConstantExpr *constantExpr ) override final;
-        virtual Expression* mutate( SizeofExpr *sizeofExpr ) override final;
-        virtual Expression* mutate( AlignofExpr *alignofExpr ) override final;
-        virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ) override final;
-        virtual Expression* mutate( OffsetofExpr *offsetofExpr ) override final;
-        virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ) override final;
-        virtual Expression* mutate( AttrExpr *attrExpr ) override final;
-        virtual Expression* mutate( LogicalExpr *logicalExpr ) override final;
-        virtual Expression* mutate( ConditionalExpr *conditionalExpr ) override final;
-        virtual Expression* mutate( CommaExpr *commaExpr ) override final;
-        virtual Expression* mutate( TypeExpr *typeExpr ) override final;
-        virtual Expression* mutate( AsmExpr *asmExpr ) override final;
-        virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) override final;
-        virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final;
-        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final;
-        virtual Expression* mutate( UntypedValofExpr *valofExpr ) override final;
-        virtual Expression* mutate( RangeExpr *rangeExpr ) override final;
-        virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final;
-        virtual Expression* mutate( TupleExpr *tupleExpr ) override final;
-        virtual Expression* mutate( TupleIndexExpr *tupleExpr ) override final;
-        virtual Expression* mutate( MemberTupleExpr *tupleExpr ) override final;
-        virtual Expression* mutate( TupleAssignExpr *assignExpr ) override final;
-        virtual Expression* mutate( StmtExpr * stmtExpr ) override final;
-        virtual Expression* mutate( UniqueExpr * uniqueExpr ) override final;
-
-        virtual Type* mutate( VoidType *basicType ) override final;
-        virtual Type* mutate( BasicType *basicType ) override final;
-        virtual Type* mutate( PointerType *pointerType ) override final;
-        virtual Type* mutate( ArrayType *arrayType ) override final;
-        virtual Type* mutate( FunctionType *functionType ) override final;
-        virtual Type* mutate( StructInstType *aggregateUseType ) override final;
-        virtual Type* mutate( UnionInstType *aggregateUseType ) override final;
-        virtual Type* mutate( EnumInstType *aggregateUseType ) override final;
-        virtual Type* mutate( TraitInstType *aggregateUseType ) override final;
-        virtual Type* mutate( TypeInstType *aggregateUseType ) override final;
-        virtual Type* mutate( TupleType *tupleType ) override final;
-        virtual Type* mutate( TypeofType *typeofType ) override final;
-        virtual Type* mutate( AttrType *attrType ) override final;
-        virtual Type* mutate( VarArgsType *varArgsType ) override final;
-        virtual Type* mutate( ZeroType *zeroType ) override final;
-        virtual Type* mutate( OneType *oneType ) override final;
-
-        virtual Initializer* mutate( SingleInit *singleInit ) override final;
-        virtual Initializer* mutate( ListInit *listInit ) override final;
-        virtual Initializer* mutate( ConstructorInit *ctorInit ) override final;
-
-        virtual Subrange *mutate( Subrange *subrange ) override final;
-
-        virtual Constant *mutate( Constant *constant ) override final;
-
-private:
-        template<typename node_type> void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); }
-        template<typename node_type> void call_postvisit( node_type * node ) { postvisit_impl( pass, node, 0 ); }
-
-        template<typename node_type> void call_premutate ( node_type * node ) { premutate_impl( pass, node, 0 ); }
-        template<typename return_type, typename node_type> return_type call_postmutate ( node_type * node ) { return postmutate_impl<return_type>( pass, node, 0 ); }
-
-        void call_beginScope() { begin_scope_impl( pass, 0 ); }
-        void call_endScope  () { end_scope_impl  ( pass, 0 ); }
-
-        void set_env( TypeSubstitution * env ) { set_env_impl( pass, env, 0); }
-
-        void visitStatementList( std::list< Statement* > &statements );
-        void mutateStatementList( std::list< Statement* > &statements );
-
-        Statement * visitStatement( Statement * stmt );
-        Statement * mutateStatement( Statement * stmt );
-
-        void visitExpression( Expression * expr );
-        Expression * mutateExpression( Expression * expr );
-
-
-        TypeSubstitution **             get_env_ptr    () { return env_impl             ( pass, 0); }
-        std::list< Statement* > *       get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); }
-        std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
+        template<typename node_type> 
+        auto call_postvisit( node_type * node )
+                -> decltype( postvisit_impl( pass, node, 0 ), void() ) 
+        { 
+                postvisit_impl( pass, node, 0 ); 
+        }
 };