Changes in src/SymTab/Validate.cc [e3e16bc:522363e]

File:

• src/SymTab/Validate.cc (modified) (24 diffs)

src/SymTab/Validate.cc

@@ -123 +123 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        class LinkReferenceToTypes final : public Indexer {
-                typedef Indexer Parent;
-          public:
-                LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
-                using Parent::visit;
-                void visit( TypeInstType *typeInst ) final;
-
-                void visit( EnumInstType *enumInst ) final;
-                void visit( StructInstType *structInst ) final;
-                void visit( UnionInstType *unionInst ) final;
-                void visit( TraitInstType *traitInst ) final;
-
-                void visit( EnumDecl *enumDecl ) final;
-                void visit( StructDecl *structDecl ) final;
-                void visit( UnionDecl *unionDecl ) final;
-                void visit( TraitDecl * traitDecl ) final;
+        struct LinkReferenceToTypes final : public WithIndexer {
+                LinkReferenceToTypes( const Indexer *indexer );
+                void postvisit( TypeInstType *typeInst );
+
+                void postvisit( EnumInstType *enumInst );
+                void postvisit( StructInstType *structInst );
+                void postvisit( UnionInstType *unionInst );
+                void postvisit( TraitInstType *traitInst );
+
+                void postvisit( EnumDecl *enumDecl );
+                void postvisit( StructDecl *structDecl );
+                void postvisit( UnionDecl *unionDecl );
+                void postvisit( TraitDecl * traitDecl );
 
           private:
-                const Indexer *indexer;
+                const Indexer *local_indexer;
 
                 typedef std::map< std::string, std::list< EnumInstType * > > ForwardEnumsType;
@@ -152 +149 @@
 
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
-        class ForallPointerDecay final : public Indexer {
-                typedef Indexer Parent;
-          public:
-                using Parent::visit;
-                ForallPointerDecay( const Indexer *indexer );
-
-                virtual void visit( ObjectDecl *object ) override;
-                virtual void visit( FunctionDecl *func ) override;
-
-                const Indexer *indexer;
+        struct ForallPointerDecay final {
+                void previsit( ObjectDecl *object );
+                void previsit( FunctionDecl *func );
         };
 
@@ -176 +166 @@
         };
 
-        class EliminateTypedef : public Mutator {
-          public:
+        struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
                 EliminateTypedef() : scopeLevel( 0 ) {}
                 /// Replaces typedefs by forward declarations
                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
+
+                Type * postmutate( TypeInstType * aggregateUseType );
+                Declaration * postmutate( TypedefDecl * typeDecl );
+                void premutate( TypeDecl * typeDecl );
+                void premutate( FunctionDecl * funcDecl );
+                void premutate( ObjectDecl * objDecl );
+                DeclarationWithType * postmutate( ObjectDecl * objDecl );
+
+                void premutate( CastExpr * castExpr );
+
+                void premutate( CompoundStmt * compoundStmt );
+                CompoundStmt * postmutate( CompoundStmt * compoundStmt );
+
+                void premutate( StructDecl * structDecl );
+                Declaration * postmutate( StructDecl * structDecl );
+                void premutate( UnionDecl * unionDecl );
+                Declaration * postmutate( UnionDecl * unionDecl );
+                void premutate( EnumDecl * enumDecl );
+                Declaration * postmutate( EnumDecl * enumDecl );
+                Declaration * postmutate( TraitDecl * contextDecl );
+
           private:
-                virtual Declaration *mutate( TypedefDecl *typeDecl );
-                virtual TypeDecl *mutate( TypeDecl *typeDecl );
-                virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
-                virtual DeclarationWithType *mutate( ObjectDecl *objDecl );
-                virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
-                virtual Type *mutate( TypeInstType *aggregateUseType );
-                virtual Expression *mutate( CastExpr *castExpr );
-
-                virtual Declaration *mutate( StructDecl * structDecl );
-                virtual Declaration *mutate( UnionDecl * unionDecl );
-                virtual Declaration *mutate( EnumDecl * enumDecl );
-                virtual Declaration *mutate( TraitDecl * contextDecl );
-
                 template<typename AggDecl>
                 AggDecl *handleAggregate( AggDecl * aggDecl );
@@ -256 +253 @@
         };
 
-        void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
+        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
                 PassVisitor<EnumAndPointerDecay> epc;
-                LinkReferenceToTypes lrt( doDebug, 0 );
-                ForallPointerDecay fpd( 0 );
+                PassVisitor<LinkReferenceToTypes> lrt( nullptr );
+                PassVisitor<ForallPointerDecay> fpd;
                 PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
@@ -286 +283 @@
         void validateType( Type *type, const Indexer *indexer ) {
                 PassVisitor<EnumAndPointerDecay> epc;
-                LinkReferenceToTypes lrt( false, indexer );
-                ForallPointerDecay fpd( indexer );
+                PassVisitor<LinkReferenceToTypes> lrt( indexer );
+                PassVisitor<ForallPointerDecay> fpd;
                 type->accept( epc );
                 type->accept( lrt );
@@ -401 +398 @@
         }
 
-        LinkReferenceToTypes::LinkReferenceToTypes( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
+        LinkReferenceToTypes::LinkReferenceToTypes( const Indexer *other_indexer ) {
                 if ( other_indexer ) {
-                        indexer = other_indexer;
+                        local_indexer = other_indexer;
                 } else {
-                        indexer = this;
-                } // if
-        }
-
-        void LinkReferenceToTypes::visit( EnumInstType *enumInst ) {
-                Parent::visit( enumInst );
-                EnumDecl *st = indexer->lookupEnum( enumInst->get_name() );
+                        local_indexer = &indexer;
+                } // if
+        }
+
+        void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
+                EnumDecl *st = local_indexer->lookupEnum( enumInst->get_name() );
                 // it's not a semantic error if the enum is not found, just an implicit forward declaration
                 if ( st ) {
@@ -423 +419 @@
         }
 
-        void LinkReferenceToTypes::visit( StructInstType *structInst ) {
-                Parent::visit( structInst );
-                StructDecl *st = indexer->lookupStruct( structInst->get_name() );
+        void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
+                StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
@@ -437 +432 @@
         }
 
-        void LinkReferenceToTypes::visit( UnionInstType *unionInst ) {
-                Parent::visit( unionInst );
-                UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
+        void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
+                UnionDecl *un = local_indexer->lookupUnion( unionInst->get_name() );
                 // it's not a semantic error if the union is not found, just an implicit forward declaration
                 if ( un ) {
@@ -492 +486 @@
         }
 
-        void LinkReferenceToTypes::visit( TraitDecl * traitDecl ) {
-                Parent::visit( traitDecl );
-
+        void LinkReferenceToTypes::postvisit( TraitDecl * traitDecl ) {
                 if ( traitDecl->name == "sized" ) {
                         // "sized" is a special trait - flick the sized status on for the type variable
@@ -516 +508 @@
         }
 
-        void LinkReferenceToTypes::visit( TraitInstType * traitInst ) {
-                Parent::visit( traitInst );
+        void LinkReferenceToTypes::postvisit( TraitInstType * traitInst ) {
                 // handle other traits
-                TraitDecl *traitDecl = indexer->lookupTrait( traitInst->name );
+                TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
                         throw SemanticError( "use of undeclared trait " + traitInst->name );
@@ -540 +531 @@
         }
 
-        void LinkReferenceToTypes::visit( EnumDecl *enumDecl ) {
+        void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
                 // visit enum members first so that the types of self-referencing members are updated properly
-                Parent::visit( enumDecl );
                 if ( ! enumDecl->get_members().empty() ) {
                         ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->get_name() );
@@ -554 +544 @@
         }
 
-        void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
+        void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
-                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and and their defaults)
-                Parent::visit( structDecl );
+                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
                 if ( ! structDecl->get_members().empty() ) {
                         ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
@@ -569 +558 @@
         }
 
-        void LinkReferenceToTypes::visit( UnionDecl *unionDecl ) {
-                Parent::visit( unionDecl );
+        void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
                         ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
@@ -582 +570 @@
         }
 
-        void LinkReferenceToTypes::visit( TypeInstType *typeInst ) {
-                if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
+        void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
+                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
                                 typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
                         } // if
-                } // if
-        }
-
-        ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) :  Indexer( false ) {
-                if ( other_indexer ) {
-                        indexer = other_indexer;
-                } else {
-                        indexer = this;
                 } // if
         }
@@ -626 +606 @@
         }
 
-        void ForallPointerDecay::visit( ObjectDecl *object ) {
+        void ForallPointerDecay::previsit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
                         forallFixer( pointer->get_base() );
                 } // if
-                Parent::visit( object );
                 object->fixUniqueId();
         }
 
-        void ForallPointerDecay::visit( FunctionDecl *func ) {
+        void ForallPointerDecay::previsit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
-                Parent::visit( func );
                 func->fixUniqueId();
         }
@@ -667 +645 @@
 
         void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
-                EliminateTypedef eliminator;
+                PassVisitor<EliminateTypedef> eliminator;
                 mutateAll( translationUnit, eliminator );
-                if ( eliminator.typedefNames.count( "size_t" ) ) {
+                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
                         // grab and remember declaration of size_t
-                        SizeType = eliminator.typedefNames["size_t"].first->get_base()->clone();
+                        SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
                 } else {
                         // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
@@ -681 +659 @@
         }
 
-        Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
+        Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
                 // of a typdef type, link the instance to its actual type.
@@ -696 +674 @@
                                 rtt->get_parameters().clear();
                                 cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
-                                mutateAll( rtt->get_parameters(), *this );  // recursively fix typedefs on parameters
+                                mutateAll( rtt->get_parameters(), *visitor );  // recursively fix typedefs on parameters
                         } // if
                         delete typeInst;
@@ -708 +686 @@
         }
 
-        Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) {
-                Declaration *ret = Mutator::mutate( tyDecl );
-
+        Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
                 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
                         // typedef to the same name from the same scope
@@ -741 +717 @@
                         return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
                 } else {
-                        return ret->clone();
-                } // if
-        }
-
-        TypeDecl *EliminateTypedef::mutate( TypeDecl * typeDecl ) {
+                        return tyDecl->clone();
+                } // if
+        }
+
+        void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
                 TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
                 if ( i != typedefNames.end() ) {
@@ -752 +728 @@
 
                 typedeclNames[ typeDecl->get_name() ] = typeDecl;
-                return Mutator::mutate( typeDecl );
-        }
-
-        DeclarationWithType *EliminateTypedef::mutate( FunctionDecl * funcDecl ) {
-                typedefNames.beginScope();
-                DeclarationWithType *ret = Mutator::mutate( funcDecl );
-                typedefNames.endScope();
-                return ret;
-        }
-
-        DeclarationWithType *EliminateTypedef::mutate( ObjectDecl * objDecl ) {
-                typedefNames.beginScope();
-                DeclarationWithType *ret = Mutator::mutate( objDecl );
-                typedefNames.endScope();
-
-                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) { // function type?
+        }
+
+        void EliminateTypedef::premutate( FunctionDecl * ) {
+                GuardScope( typedefNames );
+        }
+
+        void EliminateTypedef::premutate( ObjectDecl * ) {
+                GuardScope( typedefNames );
+        }
+
+        DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
+                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
                         // replace the current object declaration with a function declaration
-                        FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );
+                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
                         objDecl->get_attributes().clear();
                         objDecl->set_type( nullptr );
@@ -775 +747 @@
                         return newDecl;
                 } // if
-                return ret;
-        }
-
-        Expression *EliminateTypedef::mutate( CastExpr * castExpr ) {
-                typedefNames.beginScope();
-                Expression *ret = Mutator::mutate( castExpr );
-                typedefNames.endScope();
-                return ret;
-        }
-
-        CompoundStmt *EliminateTypedef::mutate( CompoundStmt * compoundStmt ) {
-                typedefNames.beginScope();
+                return objDecl;
+        }
+
+        void EliminateTypedef::premutate( CastExpr * ) {
+                GuardScope( typedefNames );
+        }
+
+        void EliminateTypedef::premutate( CompoundStmt * ) {
+                GuardScope( typedefNames );
                 scopeLevel += 1;
-                CompoundStmt *ret = Mutator::mutate( compoundStmt );
-                scopeLevel -= 1;
+                GuardAction( [this](){ scopeLevel -= 1; } );
+        }
+
+        CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
                 // remove and delete decl stmts
                 filter( compoundStmt->kids, [](Statement * stmt) {
@@ -799 +770 @@
                         return false;
                 }, true);
-                typedefNames.endScope();
-                return ret;
+                return compoundStmt;
         }
 
@@ -827 +797 @@
         }
 
-        Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {
+        void EliminateTypedef::premutate( StructDecl * structDecl ) {
                 addImplicitTypedef( structDecl );
-                Mutator::mutate( structDecl );
+        }
+
+
+        Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
                 return handleAggregate( structDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
+        void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
                 addImplicitTypedef( unionDecl );
-                Mutator::mutate( unionDecl );
+        }
+
+        Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
                 return handleAggregate( unionDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {
+        void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
                 addImplicitTypedef( enumDecl );
-                Mutator::mutate( enumDecl );
+        }
+
+        Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
                 return handleAggregate( enumDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) {
-                Mutator::mutate( contextDecl );
-                return handleAggregate( contextDecl );
+        Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
+                return handleAggregate( traitDecl );
         }