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

File:

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

src/SymTab/Validate.cc

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